コード例 #1
0
ファイル: allskyData.py プロジェクト: paalge/paskil
    def getNearest(self, time):
        """
        Returns an allskyImage object corresponding to the image in the dataset 
        which has a creation time closest to the specified time. The time 
        argument should be a datetime object. 
        """
        filename, site_info_filename = self.getNearestFilename(time)

        return allskyImage.new(filename, site_info_filename)
コード例 #2
0
ファイル: allskyData.py プロジェクト: paalge/paskil
    def getImagesInRange(self, time1, time2):
        """
        Returns a list of allskyImage objects containing all the images that 
        correspond to times between time1 and time2 (inclusive). The list will 
        be ordered in chronological order. The time arguments should be 
        datetime objects. This function creates a new instance of the 
        allskyImage class for each image in the range. 
        """
        filenames = self.getFilenamesInRange(time1, time2)

        return [allskyImage.new(*x) for x in filenames]
コード例 #3
0
ファイル: allskyData.py プロジェクト: paalge/paskil
    def getImage(self, time):
        """
        Returns an allskyImage object containing the image data for the 
        specified time. If no image exists for the specified time then None is
        returned. The time argument should be a datetime object.
        """
        try:
            index = self.__times.index(time)
        except ValueError:
            return None

        return allskyImage.new(self.__filenames[index],
                               self.__site_info_files[index])
コード例 #4
0
ファイル: allskyData.py プロジェクト: paalge/paskil
    def __next__(self):
        """
        Required for the iterator protocol. Returns the next allskyImage in the
        dataset.
        """

        if self.__current_index < self.__largest_index:

            im = allskyImage.new(self.__filenames[self.__current_index][0],
                                 site_info_file=self.__filenames[self.__current_index][1])
            self.__current_index += 1

            # return image
            return im

        else:
            # all images have been returned, raise an exception from now on.
            raise StopIteration
コード例 #5
0
ファイル: plot_on_map.py プロジェクト: paalge/paskil
    parser.add_option("-f", "--field_of_view", dest="angle", action="store", default=None,
                      help="crop the image at a set angle (in degrees) from the zenith")
    
    (options, args) = parser.parse_args()

    if len(args) < 1:
        parser.error("No input file")

    return (options, args)


if __name__ == "__main__":
    options, args = __parse_cmd_line()
    
    
    if not os.path.exists(args[0]):
        print "Cannot open file \'"+args[0]+"\'. No such file."
        sys.exit()
    
    try:
        im = allskyImage.new(args[0])
    except:
        print "\'"+args[0]+"\' is not a recognised PASKIL image file."
        sys.exit()
    
    if options.angle is not None:
        im = im.binaryMask(float(options.angle))
    
    proj = im.projectToHeight(options.proj_height,background=options.background)
    proj.default()
    show()
コード例 #6
0
ファイル: allskyData.py プロジェクト: paalge/paskil
def fromList(file_names, wavelength, filetype, site_info_file=None):
    """
    Creates a dataset from a list of filenames. The file_names argument should 
    be a list of strings specifying the filenames of the files to be included. 
    The wavelength argument should be a string that matches the value of the 
    'Wavelength' field in the image metadata see allskyImagePlugins module for 
    details. The site_info_file option should be the filename of the site 
    information file (if one is required). The filetype argument is a list of 
    filetypes (e.g. ["png","jpg"]), so a dataset spanning many filetypes can be 
    prodcued using this function (if only a single filetype is desired then it 
    must be specified as ["filetype"]). A dataset spanning images with 
    different site info files can only be produced by combining several 
    datasets with different site info files. Note that images in the list 
    supplied which do not conform to the dataset's parameters will be ignored. 
    If no images are found that can be added to the dataset then ValueError is
    raised.
    """
    data = []
    mode = None
    found_wavelengths = set([])  # set of wavelengths found during the search

    # check that filetypes argument is a list - this is a common user error!
    if type(filetype) is not list:
        raise TypeError("Filetype argument should be a list.")

    for filename in file_names:
        # check if file is of correct type
        if not filename.endswith(tuple(filetype)):
            continue  # if not then skip it

        # attempt to create an allskyImage object, if there is no plugin for it,
        # then skip this file
        try:
            current_image = allskyImage.new(filename, site_info_file)

        except TypeError:
            continue  # skip file if PASKIL cannot open it
        except IOError:
            continue  # skip file if PIL cannot decode the image

        # get the image info
        info = current_image.getInfo()

        # check if the image has the correct wavelength
        current_image_wavelength = info['header']['Wavelength']
        if current_image_wavelength.find(wavelength) == -1:
            found_wavelengths.add(current_image_wavelength)
            continue  # if image has wrong wavelength then skip it

        # check the image has the correct mode, calib factor and colour table
        try:
            current_colour_table = info['processing']['applyColourTable']
        except KeyError:
            current_colour_table = None

        try:
            current_calib_factor = info['processing']['absoluteCalibration']
        except KeyError:
            current_calib_factor = None

        current_lens_projection = info['camera']['lens_projection']

        if mode == None:
            mode = current_image.getMode()
            colour_table = current_colour_table
            calib_factor = current_calib_factor
            lens_projection = current_lens_projection

        if current_image.getMode() != mode:
            print(("Warning! allskyData.fromList(): Skipping file " + filename +
                   ". Incorrect image mode."))
            continue

        if current_colour_table != colour_table:
            print(("Warning! allskyData.fromList(): Skipping file " + filename +
                   ". Incorrect colour table."))
            continue

        if current_calib_factor != calib_factor:
            print(("Warning! allskyData.fromList(): Skipping file " + filename +
                   ". Incorrect absolute calibration factor."))
            continue

        if current_lens_projection != lens_projection:
            print(("Warning! allskyData.fromList(): Skipping file " + filename +
                   ". Incorrect lens projection."))
            continue
        # read creation time from header
        time_str = info['header']['Creation Time']

        # convert to datetime object
        try:
            time = datetime.datetime.strptime(time_str,
                                              "%d %b %Y %H:%M:%S %Z")
        except ValueError:
            time = datetime.datetime.strptime(time_str.rstrip() + " GMT",
                                              "%d %b %Y %H:%M:%S %Z")

        # store data associated with this image in the data list as a tuple
        data.append((time, filename, site_info_file,
                     float(info['camera']['Radius']),
                     float(info['camera']['fov_angle'])))

    # check to make sure the dataset is not empty
    if len(data) == 0:
        raise ValueError("No images were compatible with the dataset format,"
                         " ensure you have imported the required plugins,that the wavelength "
                         "string matches that in the image header, and that you have specified "
                         "any relevant site info files. Images with the following wavelengths "
                         "were found " + str(found_wavelengths))

    # sort the list into chronological order
    if sys.version_info[0] > 2:
        data.sort()
    else:
        data.sort(misc.tupleCompare)

    # return a dataset object
    return dataset(data, wavelength, filetype, mode, colour_table,
                   calib_factor, lens_projection)
コード例 #7
0
ファイル: output_task.py プロジェクト: paalge/pysces-asi
    def execute(self, settings_manager_proxy, network_manager_proxy):
        """
        Runs the function defined in the outputs.py file for this output type
        """

        try:
            # start the proxies
            settings_manager_proxy.start()
            if (network_manager_proxy is not None):
                network_manager_proxy.start()

            # load the image using PASKIL
            self.image = allskyImage.new(self.image[0], self.image[1])

            # work out where the output should be saved
            remove_file_on_host = False
            if self.output.filename_format is not None:
                # the 'normal' case where we want the output saved on the host
                # machine
                capture_time_string = self.image.getInfo()['header'][
                    'Creation Time']
                capture_time = datetime.datetime.strptime(
                    capture_time_string, "%d %b %Y %H:%M:%S %Z")
                filename = capture_time.strftime(self.output.filename_format)

                if hasattr(self.output, "abs_path_on_host") and self.output.abs_path_on_host:

                    if not os.path.exists(os.path.normpath(self.output.folder_on_host)):
                        try:
                            os.makedirs(
                                os.path.normpath(self.output.folder_on_host))
                        except OSError:
                            pass
                    self.output_filename = os.path.normpath(
                        self.output.folder_on_host + "/" + filename)
                else:
                    if self.output.folder_on_host != "" and self.output.folder_on_host != None:
                        self.output_filename = os.path.normpath(
                            self._folder_on_host + "/" + self.output.folder_on_host + "/" + filename)
                    else:
                        self.output_filename = os.path.normpath(
                            self._folder_on_host + "/" + filename)

            elif ((self.output.filename_format is None) and (self.file_on_server is not None)):
                # the case where we only want the file copied to the server
                temp_folder = settings_manager_proxy.get(
                    ['tmp dir'])['tmp dir']
                self.output_filename = os.path.normpath(
                    temp_folder + "/" + self.file_on_server)
                remove_file_on_host = True
            else:
                # the case where we don't want any output saved
                self.output_filename = None

            # run the subtask execution function (this is what actually
            # produces the output)
            output = self.function(
                self.image, self.output, settings_manager_proxy)

            # save the output on the host
            if output is not None and self.output_filename is not None:
                try:
                    output.save(self.output_filename)
                except AttributeError:
                    # this is added for compatibility with matplotlib figure
                    # objects
                    output.savefig(self.output_filename)

                    # the following seems to be needed to break circular references in
                    # matplolib and prevent mem leaks
                    output.clf()
                    del output
                    matplotlib._pylab_helpers.Gcf().destroy_all()
                    matplotlib._pylab_helpers.gc.collect()

            # copy the output to the server if required
            if ((self.file_on_server is not None) and (network_manager_proxy is not None)):
                network_manager_proxy.copy_to_server(
                    self.output_filename, self.file_on_server)
            del self.image
            #del output

            # if we only wanted the output on the server, then remove the copy
            # on the host
            if remove_file_on_host:
                os.remove(self.output_filename)

        except Exception as ex:
            traceback.print_exc()
            raise ex

        finally:
            # shutdown the proxies
            settings_manager_proxy.exit()
            if (network_manager_proxy is not None):
                network_manager_proxy.exit()
コード例 #8
0

# Import the plugin needed to open this type of image.
from PASKIL.plugins import DSLR_NEF


# Declare filenames as global variables for convenience.
nef_file = "LYR-SLR-20080201_184252.NEF"
info_file = "NEF_site_info.txt"
background_image = "LYR-SLR-20010101_000000.NEF"
ffcalib_file = "D80_flat_field.txt"


# Open the raw image files.
print("Decoding NEF files")
raw_image = allskyImage.new(nef_file, site_info_file=info_file)
bkgd_image = allskyImage.new(background_image, site_info_file=info_file)


# The raw image object contains pixel data from all four colour
# channels of the camera. We are only interested in one of the
# green channels, so we extract that now. For the D80, the
# different colour channels are as follows: 0=red, 1=1st green,
# 2=blue, 3=2nd green. The green channels are essentially
# identical.
print("Extracting green channel")
green_image = raw_image.getChannel(1)
green_bkgd = bkgd_image.getChannel(1)


# Subtract the background image. Most methods return
コード例 #9
0
ファイル: map_projection.py プロジェクト: paalge/paskil
# Import the plugin needed to open this type of image.
from PASKIL.plugins import DSLR_LYR_JPG


# Import the pylab functions we need to save the map projection
from pylab import savefig


# Declare filenames as global variables for convenience.
jpg_file = "LYR-SLR-20081223_194416.JPG"
info_file = "jpg_site_info.txt"


# Open the image file
print("Opening image file")
image = allskyImage.new(jpg_file, info_file)


# The D80 has a 180 degree field of view. However, mountains
# obscure the view at high angles from zenith. To remove
# them we crop the image to only have a 150 degree field of
# view. Note that with PASKIL you have to specify the angle from
# zenith that you want the image cropped at. Most methods return
# a new allskyImage object - here we simply overwrite the
# original with the cropped version.
print("Cropping field of view")
image = image.binaryMask(75)


# Crop the image size to only include the field of view.
print("Cropping image to field of view size")