Exemplo n.º 1
0
 Black value from the BlackBar in the calibrator.
 

Created on Oct 10, 2010

@author: surya
'''

import logging

from GrayBar import GrayBar
from ColorBar import ColorBar
from Logging.Logger import getLog
from IANASettings.Settings import ExitCode, CalibratorConstants

log = getLog("Calibrator")
log.setLevel(logging.ERROR)

def getColorBars(qr, image, parenttags=None, level=logging.ERROR):
    ''' Extracts the ColorBars from the Image and represents them
        as ColorBar objects.
    
    Keyword Arguments:
    qr    -- QRDetector.QR object
    image -- a PIL.Image object
    parenttags -- tag string of the calling function
    level -- the logging level
    
    Returns
    A list of Calibrator.ColorBar objects representing the three colorbars.
    '''
Exemplo n.º 2
0
NOTE: The calibrator + filter dock = Stage

Created on Oct 8, 2010

@author: surya
'''

import logging

from Stage import Stage
from Calibrator import Calibrator
from Logging.Logger import getLog
from IANASettings.Settings import ExitCode, StageDetectorConstants

log = getLog("StageDetector")
log.setLevel(logging.ERROR)

def computeBoxFromQR(qr, left, right, top, bottom, parenttags=None):
    """ Uses the QR coordinates to compute the coordinates of a Box
        subject to left, right, top, bottom params.
    
    Keyword Arguments:
    left   -- distance from qrTopLeft to left
    right  -- distance from qrTopLeft to right
    top    -- distance from qrTopLeft to top
    bottom -- distance from qrTopLeft to bottom
    parenttags -- tag string of the calling function
    
    Returns:
    (topLeft, bottomLeft, bottomRight, topRight) coordinates
Exemplo n.º 3
0
Created on Oct 8, 2010

@author: surya
'''

import os
import logging

from subprocess import PIPE, Popen
from Logging.Logger import getLog
from IANASteps.Geometry.Point import Point
from QR import QR
from IANASettings.Settings import ExitCode

    
log = getLog("QRFilter")
log.setLevel(logging.ERROR)    
        
    
def detectQR(file_, parenttags=None, level=logging.ERROR):
    '''Call FindQRCode.jar to see whether QR code is correct.

    Keyword arguments:
    file_      -- The full file name toward the image file to be processed.
    parenttags -- The tag string of the calling method.
    level      -- The logging level.

    Returns:
    QR       -- an object of QRDetector.QR type.
    exitcode -- exit code returning from FindQRCode.jar.
'''
Created on Oct 13, 2010

@author: surya
'''

import logging

from PIL.Image import QUAD, BICUBIC
from Logging.Logger import getLog
from IANASettings.Settings import ExitCode

log = getLog("ImageTransformer")
log.setLevel(logging.ERROR)

def transform(image, stage, parenttags=None, level=logging.ERROR):
    ''' Performs the skew correction in the image.
        
    Keyword Arguments:
    image -- PIL.Image instance
    stage -- Absolute coordinates of the stage
    parentttags -- tag string of the calling function
    
    Returns:
    PIL.Image, The cropped image containing the stage.    
    '''
    
    # Set the logging level
    log.setLevel(level)
    tags = parenttags + " TRANSFORM"
    
Exemplo n.º 5
0
from django.views.decorators.csrf import csrf_exempt

from Collections.SuryaUploadData import *
from Collections.SuryaDeploymentData import *
from Collections.SuryaProcessingList import *
from Collections.SuryaCalibrationData import *

from SuryaWebPortal.utils.postparser import *
from SuryaWebPortal.exceptions.UploadException import UploadException 

import mongoengine

# Connect to MongoDB
connect('SuryaDB', tz_aware=True)

log = getLog('views')
log.setLevel(logging.DEBUG)


# The cell phone expect the following line as an OK signal in the first line
CUSTOMIZED_PHONE_STATUS_OK   = "upok "
CUSTOMIZED_PHONE_STATUS_FAIL = "svrfail "





def get_post_config():
    # (required, type, db_name, default, parser)
    return { \
        "device_id": PostParserArgs(True, "string", "device_id", "None", None), \
The CircleFilter Module uses the Hough Transform to detect circles in a given image

Created on Oct 5, 2010

@author: surya
'''

import opencv
import logging

from BCFilter import BCFilter
from Logging.Logger import getLog
from IANASettings.Settings import BCFilterConstants
from IANASettings.Settings import ExitCode

log = getLog("BCFilterDetector")
log.setLevel(logging.ERROR)

def splitToBands(image):
    ''' Split the given image into separate bands
    
    Keyword Arguments:
    image -- a PIL.Image object
    
    Returns:
    if the Image is RGB bands corresponding to R,G,B bands of the image
    if the Image is GrayScale then a single band containing the iage itself  
    '''

    if image.mode == 'L':
        bands = (image,)
Exemplo n.º 7
0
import os
import sys
import errno
import os.path
import logging
import StringIO
import PIL
import PIL.JpegImagePlugin
import PIL.Image as Image
import PIL.ImageDraw as ImageDraw
import PIL.ImageFont as ImageFont
from Logging.Logger import getLog



log = getLog("ImageResize")
log.setLevel(logging.ERROR)


def imageRotate(imagefile, deg):
    '''Rotate image'''
    # check for string or a mongo gridfs file object
    log.error("imagefile type is: " + str(imagefile.__class__))
    if isinstance(imagefile, str):
        if not os.path.isfile(imagefile):
            log.error('imagefile ' + imagefile + ' does not exist', extra=tags)
            return None, ExitCode.FileNotExists
        image = Image.open(imagefile)
    elif isinstance(imagefile, PIL.JpegImagePlugin.JpegImageFile) or isinstance(imagefile, PIL.Image.Image):
        image = imagefile
    else:
Exemplo n.º 8
0
'''
Created on Oct 12, 2010

@author: surya
'''

import pylab
import logging

from BCCResult import BCCResult
from Logging.Logger import getLog
from IANAUtil.Rating import Rating
from Scientific.Functions.LeastSquares import leastSquaresFit
from IANASettings.Settings import ExitCode, BCCCalculatorConstants

log = getLog("BCCCalculator")
log.setLevel(logging.ERROR)

def computeBCC(bcFilterRadius, bcLoading, exposedTime, flowRate):
    ''' Computes the black carbon concentration(ug/cm^3) according to the formula
        
        BCC(ug/L) = (bcFilterArea(cm^2) * bcLoading(ug/cm^2)) / (exposedTime(min) * flowRate(L/min))
        
        NOTE : since cm^3 = L/1000
        
        BCC(ug/cm^3) = BCC(ug/L) * 1000
        
        Keyword arguments:
        bcFilterArea  -- The Radius of the filter in cm
        bcLoading     -- The black carbin loading value in ug/cm^2
        exposedTime   -- The exposure time of the bcfilter in mins
Exemplo n.º 9
0
#!/usr/bin/python


import logging
from Logging.Logger import getLog
from django import forms


log = getLog('forms')
log.setLevel(logging.DEBUG)


class DownloadDataForm(forms.Form):
    startDateTime = forms.DateField(required=True, label='Start Date',
                                    widget=forms.DateInput(attrs={'class':'date_picker'}, format='%m/%d/%Y'))
    stopDateTime = forms.DateField(required=True, label='Stop Date',
                                   widget=forms.DateInput(attrs={'class':'date_picker'}, format='%m/%d/%Y'))
    
    def __init__(self, *args, **kwards):
        super(DownloadDataForm, self).__init__(*args, **kwards)
        #self.fields['deviceId'].choices = [ (d.deviceId, "%-10s - %s" % (str(d.deviceName), d.deviceId)) for d in DeviceData.objects ]

    def clean_startDateTime(self):
        try:
            d = self.cleaned_data['startDateTime']
            dt = datetime(d.year, d.month, d.day)
            self.cleaned_data['startDateTime'] = dt
            print "now is " + str(self.cleaned_data)
            return dt
        except:
            raise forms.ValidationError("Invalid Start Date.")
Exemplo n.º 10
0
from django.core.paginator import Paginator, InvalidPage, EmptyPage

from Collections.SuryaUploadData import *
from Collections.SuryaGroundTruth import *
from Collections.SuryaDeploymentData import *
from Collections.SuryaProcessingList import *
from Collections.SuryaProcessResult import *
from Collections.SuryaCalibrationData import *


import mongoengine

# Connect to MongoDB
connect("SuryaDB")

log = getLog("views")
log.setLevel(logging.DEBUG)


@login_required
def debug(request):
    if not request.user.is_staff:
        return redirect("SuryaWebPortal.views.home.home")

    t = loader.get_template("debug/debug.html")
    c = RequestContext(request, {})
    return HttpResponse(t.render(c))


@login_required
def uploads(request, objID=None):
Exemplo n.º 11
0
import PIL.ImageFont as ImageFont
from optparse import OptionParser
 
from Logging.Logger import getLog
from IANASteps.Geometry.Point import Point
from IANASettings.Settings import ExitCode, MainConstants, CalibratorConstants
from IANASteps.QRDetector.QRDetector import detectQR
from IANASteps.StageDetector.StageDetector import detectStage, detectCalibrator
from IANASteps.ImageTransformer.ImageTransformer import transform
from IANASteps.Calibrator.Calibrator import getGrayBars
from IANASteps.BCFilterDetector.BCFilterDetector import splitToBands, detectBCFilter, select, PsycoInit
from IANASteps.BCCCalculator.BCCCalculator import rateFilter
from IANAUtil.Chart import plotChart
from optparse import OptionParser

log = getLog("Main")
log.setLevel(logging.ERROR)

def Main(imagefile, filterRadius, bcGradient, exposedTime, airFlowRate, imageLogLevel, debugImageFile, chartFile, parenttags=None, level=logging.ERROR,):
    ''' This method analyzes the imageFile, and uses the given parameters to comptute the BCC
    
    Keyword Arguments:
    imagefile    -- The image file on which to perform the black carbon concentration analysis
    filterRadius -- The radius of the filter in the image
    bcGradient   -- The gradient values to be used in the interpolation to ind the BCVol.
    exposedTime  -- The time duration for which the filter was exposed.
    airFlowRate  -- The flowrate of the pump.
    imageLogLevel-- 0, no logging, 1 log image, 2 log and show image
    debugImageFile -- The name of the debugImage in which to store the image processing debug info.
    chartFile    -- The name of the chartFile in which to store the plotted results.
    parenttags   -- The tagstring of the calling function
Exemplo n.º 12
0
import psyco
import traceback
import PIL.Image as Image
import PIL.ImageDraw as ImageDraw
import PIL.ImageFont as ImageFont

from Logging.Logger import getLog
from IANASteps.Geometry.Point import Point
from IANASteps.QRDetector.QRDetector import detectQR
from IANASteps.Calibrator.Calibrator import getGrayBars
from IANASteps.StageDetector.StageDetector import detectStage, detectCalibrator
from IANASteps.ImageTransformer.ImageTransformer import transform
from IANASettings.Settings import ExitCode, MainConstants, CalibratorConstants, BCFilterConstants
from IANASteps.BCFilterDetector.BCFilterDetector import splitToBands, detectBCFilter, select, PsycoInit

log = getLog("FeatureExtractor")
log.setLevel(logging.ERROR)


def saveDebugImage(debugImage, debugImagefile, tags):
    """ Saves the PIL.Image debugImage to the debugImagefile
    
        Keyword Arguments:
        debugImage     -- a PIL.Image object
        debugImagefile -- a file or string
        tags           -- tag string of the caliing function for logging
    """
    if isinstance(debugImagefile, str):
        debugImage.save(debugImagefile)
    else:
        try:
Exemplo n.º 13
0
Created on Nov 2, 2010

@author: surya
'''
'''
Created on Oct 30, 2010

@author: surya
'''

import os
import logging

from Logging.Logger import getLog

log = getLog('AppLock')
log.setLevel(logging.DEBUG)

def getLock(lockFileName, programName, level=logging.DEBUG):
    ''' Creates a lock file given by the lockname and puts a pid of the current process
        in the lock file. If the lock file exists it checks if the a process given by the
        pid in the lock file is running. If such a process exits it returns False indicating
        failure to create a lock file.  
        
        Returns:
        Boolean -- True if the process represented by programName isn't already running, False
                   otherwise.
        
    '''
    
    if os.path.exists(lockFileName):
'''
Created on Nov 2, 2010

@author: surya
'''

import logging

from Logging.Logger import getLog
from IANASteps.BCCCalculator.BCCCalculator import rateFilter
from IANAUtil.Chart import plotChart
from IANASettings.Settings import ExitCode

log = getLog('BCCResultComputation')

def bccResultComputation(sampledRGB, filterRadius, exposedTime, airFlowRate, bcGradient, gradient, chartFile, parenttags=None, level=logging.ERROR):
    ''' This method gets invoked externally with the specified params and computes the BCVol,
        it also plots the chart.
        
    Keyword Arguments:
    sampledRGB   -- The sampled RGB values of the BCFilter
    filterRadius -- The radius of the filter in the image
    exposedTime  -- The time duration for which the filter was exposed.
    airFlowRate  -- The flowrate of the pump
    bcGradient   -- The gradient values to be used in the interpolation to ind the BCVol
    gradient     -- The gradient/grayscale list that is used in the interpolation
    chartFile    -- The name of the chartFile in which to store the plotted results
    parenttags   -- The tag string of the calling function
    level        -- The logging level
    
    Returns: