#!/usr/bin/env python#This file is used to search for bad sectors in a given image. #How this works:##This works by creating an asterisk like area around a point with 8 "arms" of the asterisk. It then takes the median of every asterisk and calculate if#the median is too high. If it is, it probably is a bad pixel. #NumPy library needed for the median and the array handling. NumPy is pythons#C based number cruncher.from numpy import numarray, zeros, insertfrom scipy.weave import inlinefrom scipy.weave import converters#Psyco is a specializing compiler for python. It makes number crunching faster - but this is a C module. You cant use psyco.######################### ImageLuminosity and ImageInformation #######################Variables to function:#the image map as a 2-D array#kernel_outer_radius #kernel_inner_radius#output: new median filtered image map#what we are trying to do: We are taking an image and selecting a pixel, x in the image.#Now, we select a "star" shaped zone around it and apply the MEDIAN of all the values in the star#as a new value to the element x in the array. This "smoothes" the bad pixels out.#"The function is actually rather simple. It takes a real array of size n_rows and n_cols as input, along#with two integer parameters called kernel_outer_radius and kernel_inner_radius.#The function outputs a real array of size n_rows and n_cols which, at each pixel,#is the median value of the pixels in the kernel pattern of the input array.#It is a "smoothing" function.def image_map_and_luminosity(unfiltered_image_as_array, zone_outer_radius, zone_inner_radius): #Determine the size of the image first using numpy's ndarray.shape command #This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m) unfiltered_image_dimentions=unfiltered_image_as_array.shape n_rows = unfiltered_image_dimentions[0] n_columns = unfiltered_image_dimentions[1] n_pixels = n_rows*n_columns #now pad the array for processing for x in xrange(zone_outer_radius): origDim = unfiltered_image_as_array.shape nRows = origDim[0] nColumns = origDim[1] unfiltered_image_as_array = insert(unfiltered_image_as_array, nRows, 0, axis=0) unfiltered_image_as_array = insert(unfiltered_image_as_array,nColumns,0, axis=1) unfiltered_image_as_array = insert(unfiltered_image_as_array, 0, 0, axis=0) unfiltered_image_as_array = insert(unfiltered_image_as_array,0,0, axis=1) #unfiltered_image_as_array = arraypad(unfiltered_image_as_array, zone_outer_radius, 0) #Perform checks that the zone_outer_radius is not less than zone_inner_radius and zone_inner_radius is not less than 1. if zone_inner_radius < 1: zone_inner_radius=1 if zone_outer_radius < zone_inner_radius: zone_outer_radius=zone_inner_radius zone_vector_size=8*(zone_outer_radius) zone_vector = zeros((zone_vector_size)) #Initiate the new image array where we will be writing our new image to. new_image_as_array = zeros((n_rows, n_columns)) #now; we must process the image. midpoint = 8*(zone_outer_radius-zone_inner_radius) cMedianProcessorCode=""" int process_point_row, process_point_column, zone_median; int zone_vector_size=0; for (int zone_row=zone_outer_radius; zone_row<=n_rows+zone_outer_radius; zone_row++) { for (int zone_col=zone_outer_radius; zone_col<=n_columns+zone_outer_radius; zone_col++) { for (int i_zone=zone_inner_radius; i_zone<=zone_outer_radius; i_zone++) { process_point_row=zone_row-i_zone; process_point_column=zone_col-i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row; process_point_column=zone_col-i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row+i_zone; process_point_column=zone_col-i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row-i_zone; process_point_column=zone_col; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row+i_zone; process_point_column=zone_col; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row+i_zone; process_point_column=zone_col+i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row; process_point_column=zone_col+i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); process_point_row=zone_row-i_zone; process_point_column=zone_col+i_zone; zone_vector(++zone_vector_size)=unfiltered_image_as_array(process_point_row, process_point_column); } int median = (zone_vector_size - zone_vector_size%2)/2; float temp; for(int i=0; i<zone_vector_size; i++) { for(int j=i+1; j<zone_vector_size; j++) { if(zone_vector(i)>zone_vector(j)) { temp=zone_vector(j); zone_vector(j)=zone_vector(i); zone_vector(i)=temp; } } } zone_median=zone_vector(median); zone_vector_size=0; new_image_as_array(zone_row-zone_outer_radius,zone_col-zone_outer_radius)=zone_median; } } """ inline(cMedianProcessorCode,['unfiltered_image_as_array', 'new_image_as_array', 'zone_inner_radius', 'zone_outer_radius', 'n_rows', 'zone_vector', 'n_columns'],type_converters=converters.blitz) return new_image_as_array