class BRAINSDiscreteClassInputSpec(CommandLineInputSpec): inputVolume = File(exists="True", argstr="--inputVolume %s") subcorticalMask = File(exists="True", argstr="--subcorticalMask %s") outputVolume = traits.Either(traits.Bool, File, argstr="--outputVolume %s") subcorticalThreshold = traits.Float(argstr="--subcorticalThreshold %f") corticalThreshold = traits.Float(argstr="--corticalThreshold %f") csfThreshold = traits.Float(argstr="--csfThreshold %f")
class BRAINSClassPlugsInputSpec(CommandLineInputSpec): t1Volume = File(exists="True", argstr="--t1Volume %s") t2Volume = File(exists="True", argstr="--t2Volume %s") pdVolume = File(exists="True", argstr="--pdVolume %s") searchVolume = File(exists="True", argstr="--searchVolume %s") gmPlugs = traits.Either(traits.Bool, File, argstr="--gmPlugs %s") wmPlugs = traits.Either(traits.Bool, File, argstr="--wmPlugs %s") csfPlugs = traits.Either(traits.Bool, File, argstr="--csfPlugs %s") plugClassNames = traits.List("traits.Str", sep=",", argstr="--plugClassNames %s") t1ClassMeans = traits.List("traits.Float", sep=",", argstr="--t1ClassMeans %f") t2ClassMeans = traits.List("traits.Float", sep=",", argstr="--t2ClassMeans %f") pdClassMeans = traits.List("traits.Float", sep=",", argstr="--pdClassMeans %f") randomSeed = traits.Int(argstr="--randomSeed %d") numberOfPlugs = traits.Int(argstr="--numberOfPlugs %d") coverage = traits.Float(argstr="--coverage %f") permissiveness = traits.Float(argstr="--permissiveness %f") meanOutlier = traits.Float(argstr="--meanOutlier %f") varOutlier = traits.Float(argstr="--varOutlier %f") plugSize = traits.Float(argstr="--plugSize %f") partitions = traits.List("traits.Int", sep=",", argstr="--partitions %d") numberOfClassPlugs = traits.List("traits.Int", sep=",", argstr="--numberOfClassPlugs %d") bloodMode = traits.Enum("Manual", "Top", "Bottom", argstr="--bloodMode %s") bloodImage = traits.Enum("T1", "T2", "PD", argstr="--bloodImage %s") vbPlugs = File(exists="True", argstr="--vbPlugs %s")
class StripeClass(remote_traits.MaybeRemoteHasTraits): gain = traits.Float(-40.0) # in (degrees per second) / degrees offset = traits.Float(0.0) # in degrees per second traits_view = View( Group((Item(name='gain', label='gain [ (deg/sec) / deg ]'), Item(name='offset', label='offset [ deg/sec ]'))), )
class LineRC(traits.HasTraits): linewidth = traits.Float(0.5) linestyle = traits.Trait(*linestyles) color = Color marker = traits.Trait(*linemarkers) markerfacecolor = Color markeredgecolor = Color markeredgewidth = traits.Float(0.5) markersize = traits.Float(6) antialiased = flexible_true_trait data_clipping = flexible_false_trait
class gtractFastMarchingTrackingInputSpec(CommandLineInputSpec): inputTensorVolume = File( exists = "True",argstr = "--inputTensorVolume %s") inputAnisotropyVolume = File( exists = "True",argstr = "--inputAnisotropyVolume %s") inputCostVolume = File( exists = "True",argstr = "--inputCostVolume %s") inputStartingSeedsLabelMapVolume = File( exists = "True",argstr = "--inputStartingSeedsLabelMapVolume %s") startingSeedsLabel = traits.Int( argstr = "--startingSeedsLabel %d") outputTract = traits.Str( argstr = "--outputTract %s") writeXMLPolyDataFile = traits.Bool( argstr = "--writeXMLPolyDataFile ") numberOfIterations = traits.Int( argstr = "--numberOfIterations %d") seedThreshold = traits.Float( argstr = "--seedThreshold %f") trackingThreshold = traits.Float( argstr = "--trackingThreshold %f") costStepSize = traits.Float( argstr = "--costStepSize %f") maximumStepSize = traits.Float( argstr = "--maximumStepSize %f") minimumStepSize = traits.Float( argstr = "--minimumStepSize %f")
class lines(TConfig): linewidth = T.Float(1.0) linestyle = T.Trait('-', '--', '-.', ':', 'steps', '', ' ', None) color = T.Trait('blue', mplT.ColorHandler()) solid_joinstyle = T.Trait('round', 'miter', 'round', 'bevel') solid_capstyle = T.Trait('butt', 'butt', 'round', 'projecting') dash_joinstyle = T.Trait('round', 'miter', 'round', 'bevel') dash_capstyle = T.Trait('butt', 'butt', 'round', 'projecting') marker = T.Trait('None', 'None', 'o', '.', ',', '^', 'v', '<', '>', 's', '+', 'x', 'D', 'd', '1', '2', '3', '4', 'h', 'H', 'p', '|', '_') markeredgewidth = T.Float(0.5) markersize = T.Float(6) antialiased = T.true
class font(TConfig): family = T.Trait('sans-serif', 'sans-serif', 'serif', 'cursive', 'fantasy', 'monospace') style = T.Trait('normal', 'normal', 'italic', 'oblique') variant = T.Trait('normal', 'normal', 'small-caps') weight = T.Trait('normal', 'normal', 'bold', 'bolder', 'lighter', 100, 200, 300, 400, 500, 600, 700, 800, 900) stretch = T.Trait('normal', 'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded', 'wider', 'narrower') size = T.Float(12.0) serif = T.ListStr([ "Bitstream Vera Serif", "New Century Schoolbook", "Century Schoolbook L", "Utopia", "ITC Bookman", "Bookman", "Nimbus Roman No9 L", "Times New Roman", "Times", "Palatino", "Charter", "serif" ]) sans_serif = T.ListStr([ "Bitstream Vera Sans", "Lucida Grande", "Verdana", "Geneva", "Lucid", "Arial", "Helvetica", "Avant Garde", "sans-serif" ]) cursive = T.ListStr( ["Apple Chancery", "Textile", "Zapf Chancery", "Sand", "cursive"]) fantasy = T.ListStr([ "Comic Sans MS", "Chicago", "Charcoal", "Impact", "Western", "fantasy" ]) monospace = T.ListStr([ "Bitstream Vera Sans Mono", "Andale Mono", "Nimbus Mono L", "Courier New", "Courier", "Fixed", "Terminal", "monospace" ])
class Patch(Artist, traits.HasTraits): linewidth = traits.Float(0.5) facecolor = Color fc = facecolor edgecolor = Color fill = flexible_true_trait def __init__(self, edgecolor=None, facecolor=None, linewidth=None, antialiased=None, fill=1, **kwargs): Artist.__init__(self) if edgecolor is None: edgecolor = rc.patch.edgecolor if facecolor is None: facecolor = rc.patch.facecolor if linewidth is None: linewidth = rc.patch.linewidth if antialiased is None: antialiased = rc.patch.antialiased self.edgecolor = edgecolor self.facecolor = facecolor self.linewidth = linewidth self.antialiased = antialiased self.fill = fill
class DicomToNrrdConverterInputSpec(CommandLineInputSpec): inputDicomDirectory = Directory( exists = "True",argstr = "--inputDicomDirectory %s") outputDirectory = traits.Either(traits.Bool, Directory, argstr = "--outputDirectory %s") outputVolume = traits.Str( argstr = "--outputVolume %s") smallGradientThreshold = traits.Float( argstr = "--smallGradientThreshold %f") writeProtocolGradientsFile = traits.Bool( argstr = "--writeProtocolGradientsFile ") useIdentityMeaseurementFrame = traits.Bool( argstr = "--useIdentityMeaseurementFrame ") useBMatrixGradientDirections = traits.Bool( argstr = "--useBMatrixGradientDirections ")
class JFIEmulatorClass(remote_traits.MaybeRemoteHasTraits): """base class of worker subclass, and also runs in GUI process""" max_voltage = traits.Float(4.0) volts_to_adc_units = traits.Float(1000) # conversion factor BoardNum = traits.Int(0) chan_left = traits.Int(0) chan_right = traits.Int(1) min_angle = traits.Float(-45) # in same units as sent by strokelitude max_angle = traits.Float(90) # in same units as sent by strokelitude gain = UL.UNI4VOLTS # works on USB 1208FS traits_view = View( Group(( ## Item(name='max_voltage'), ## Item(name='volts_to_adc_units'), )), )
class compareTractInclusionInputSpec(CommandLineInputSpec): testFiber = traits.Str( argstr = "--testFiber %s") standardFiber = traits.Str( argstr = "--standardFiber %s") closeness = traits.Float( argstr = "--closeness %f") numberOfPoints = traits.Int( argstr = "--numberOfPoints %d") testForBijection = traits.Bool( argstr = "--testForBijection ") testForFiberCardinality = traits.Bool( argstr = "--testForFiberCardinality ") writeXMLPolyDataFile = traits.Bool( argstr = "--writeXMLPolyDataFile ")
class PassengerTabularAdapter(TabularAdapter): """An adapter for table-based views of multiple passengers.""" columns = [('ID', 'ID'), ('Origin', 'src_station'), ('Destination', 'dest_station'), ('Wait Time', 'wait_time'), ('Ride Time', 'ride_time'), ('Walk Time', 'walk_time'), ('Total Time', 'total_time'), ('Trip Success', 'trip_success'), ('Current Location', 'loc'), ('Load Delay', 'load_delay'), ('Unload Delay', 'unload_delay'), ('Mass', 'mass'), ('Will Share', 'will_share')] ID_width = traits.Float(40) wait_time_text = traits.Property ride_time_text = traits.Property walk_time_text = traits.Property total_time_text = traits.Property load_delay_text = traits.Property unload_delay_text = traits.Property ID_tooltip = traits.Constant('Unique passenger identifier') src_station_tooltip = traits.Constant( "ID or label for the passenger's origin station.") dest_station_tooltip = traits.Constant( "ID or label for the passenger's destination station.") wait_time_tooltip = traits.Constant('Time spent waiting at a station') ride_time_tooltip = traits.Constant('Time spent riding in a vehicle') walk_time_tooltip = traits.Constant('Time spent walking to a station') total_time_tooltip = traits.Constant('Sum of time spent on trip') loc_tooltip = traits.Constant('ID or label for a station or vehicle') trip_success_tooltip = traits.Constant( 'Passenger has sucessfully reached its destination') load_delay_tooltip = traits.Constant( 'Time that passenger requires to enter a vehicle') unload_delay_tooltip = traits.Constant( 'Time that passenger requires to exit a vehicle') mass_tooltip = traits.Constant( 'Total passenger weight, including luggage (kg)') will_share_tooltip = traits.Constant( 'Whether the passenger will share a vehicle with another passenger if they have the same origin and destination stations.' ) def _get_wait_time_text(self): return sec_to_hms(self.item.wait_time) def _get_ride_time_text(self): return sec_to_hms(self.item.ride_time) def _get_walk_time_text(self): return sec_to_hms(self.item.walk_time) def _get_total_time_text(self): return sec_to_hms(self.item.total_time) def _get_load_delay_text(self): return sec_to_hms(self.item.load_delay) def _get_unload_delay_text(self): return sec_to_hms(self.item.unload_delay)
class N4ITKInputSpec(CommandLineInputSpec): inputImageName = File(exists="True", argstr="--inputimage %s") maskImageName = File(exists="True", argstr="--maskimage %s") outputImageName = traits.Either(traits.Bool, File, argstr="--outputimage %s") outputBiasFieldName = traits.Either(traits.Bool, File, argstr="--outputbiasfield %s") Force2D = traits.Bool(argstr="--force2D ") numberOfIterations = traits.List("traits.Int", sep=",", argstr="--iterations %d") convergenceThreshold = traits.Float(argstr="--convergencethreshold %f") initialMeshResolution = traits.List("traits.Float", sep=",", argstr="--meshresolution %f") splineDistance = traits.Float(argstr="--splinedistance %f") shrinkFactor = traits.Int(argstr="--shrinkfactor %d") bsplineOrder = traits.Int(argstr="--bsplineorder %d") weightImageName = File(exists="True", argstr="--weightimage %s") alpha = traits.Float(argstr="--bsplinealpha %f") beta = traits.Float(argstr="--bsplinebeta %f") histogramSharpening = traits.List("traits.Float", sep=",", argstr="--histogramsharpening %f") biasFieldFullWidthAtHalfMaximum = traits.Float( argstr="--biasFieldFullWidthAtHalfMaximum %f") weinerFilterNoise = traits.Float(argstr="--weinerFilterNoise %f") numberOfHistogramBins = traits.Int(argstr="--numberOfHistogramBins %d")
class subplot(TConfig): """The figure subplot parameters. All dimensions are fraction of the figure width or height""" left = T.Float(0.125) right = T.Float(0.9) bottom = T.Float(0.1) top = T.Float(0.9) wspace = T.Float(0.2) hspace = T.Float(0.2)
class figure(TConfig): figsize = T.List(T.Float, [8, 6], maxlen=2, minlen=2) dpi = T.Float(80) facecolor = T.Trait('0.75', mplT.ColorHandler()) edgecolor = T.Trait('white', mplT.ColorHandler()) class subplot(TConfig): """The figure subplot parameters. All dimensions are fraction of the figure width or height""" left = T.Float(0.125) right = T.Float(0.9) bottom = T.Float(0.1) top = T.Float(0.9) wspace = T.Float(0.2) hspace = T.Float(0.2)
class BRAINSClassifyInputSpec(CommandLineInputSpec): t1Volume = File(exists="True", argstr="--t1Volume %s") t2Volume = File(exists="True", argstr="--t2Volume %s") pdVolume = File(exists="True", argstr="--pdVolume %s") gmPlugs = File(exists="True", argstr="--gmPlugs %s") wmPlugs = traits.Either(traits.Bool, File, argstr="--wmPlugs %s") csfPlugs = File(exists="True", argstr="--csfPlugs %s") bloodPlugs = File(exists="True", argstr="--bloodPlugs %s") BrainVolume = File(exists="True", argstr="--BrainVolume %s") classVolume = traits.Either(traits.Bool, File, argstr="--classVolume %s") grossTrim = traits.Float(argstr="--grossTrim %f") spatialTrim = traits.Float(argstr="--spatialTrim %f") x = traits.Bool(argstr="--x ") y = traits.Bool(argstr="--y ") z = traits.Bool(argstr="--z ") xx = traits.Bool(argstr="--xx ") yy = traits.Bool(argstr="--yy ") zz = traits.Bool(argstr="--zz ") xy = traits.Bool(argstr="--xy ") xz = traits.Bool(argstr="--xz ") yz = traits.Bool(argstr="--yz ") histogramEqualize = traits.Bool(argstr="--histogramEqualize ") generateSeperateImages = traits.Bool(argstr="--generateSeperateImages ") excludeVolume = File(exists="True", argstr="--excludeVolume %s")
class axes(TConfig): hold = T.Trait(True, mplT.BoolHandler()) facecolor = T.Trait('white', mplT.ColorHandler()) edgecolor = T.Trait('black', mplT.ColorHandler()) linewidth = T.Float(1.0) grid = T.Trait(False, mplT.BoolHandler()) polargrid = T.Trait(True, mplT.BoolHandler()) titlesize = T.Trait('large', 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', T.Float) labelsize = T.Trait('medium', 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', T.Float) labelcolor = T.Trait('black', mplT.ColorHandler()) axisbelow = T.false class formatter(TConfig): limits = T.List(T.Float, [-7, 7], minlen=2, maxlen=2)
class legend(TConfig): isaxes = T.true numpoints = T.Int(3) fontsize = T.Trait('medium', 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', T.Float) pad = T.Float(0.2) markerscale = T.Float(1.0) labelsep = T.Float(0.01) handlelen = T.Float(0.05) handletextsep = T.Float(0.02) axespad = T.Float(0.02) shadow = T.false
class legend(TConfig): loc = T.Trait('upper right', 'best', 'upper right', 'upper left', 'lower left', 'lower right', 'right', 'center left', 'center right', 'lower center', 'upper center', 'center') isaxes = T.true numpoints = T.Int(3) fontsize = T.Trait('medium', 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', T.Float) pad = T.Float(0.2) markerscale = T.Float(1.0) labelsep = T.Float(0.01) handlelen = T.Float(0.05) handletextsep = T.Float(0.02) axespad = T.Float(0.02) shadow = T.false
class distiller(TConfig): use = T.Trait(None, None, 'ghostscript', 'xpdf', False) resolution = T.Float(6000)
class savefig(TConfig): dpi = T.Float(100) facecolor = T.Trait('white', mplT.ColorHandler()) edgecolor = T.Trait('white', mplT.ColorHandler()) orientation = T.Trait('portrait', 'portrait', 'landscape')
class DeviceAnalogInState(traits.HasTraits): """encapsulate all (relevant) analog input state on the device Making these variables a member of their own HasTraits class means that updates to the device can be treated in an atomic way. """ # Analog input state AIN0_enabled = traits.Bool(False) AIN0_name = traits.String("AIN0") AIN1_enabled = traits.Bool(False) AIN1_name = traits.String("AIN1") AIN2_enabled = traits.Bool(True) AIN2_name = traits.String("AIN2") AIN3_enabled = traits.Bool(False) AIN3_name = traits.String("AIN3") trigger_device = traits.Instance('DeviceModel',transient=True) adc_prescaler = traits.Trait(128.0,{ 128.0:0x07,64.0: 0x06, # According to Atmel's at90usb1287 manual, faster than this is # too fast to get good measurements with 8MHz crystal. ## '32': 0x05,'16': 0x04,'8': 0x03, ## '4': 0x02,'2': 0x00, # also 0x01 }) downsample_bits = traits.Range(low=0,high=2**5-1,value=0) AIN_running = traits.Bool(False) sample_rate_total = traits.Property(label='Sample rate (Hz), all channels', depends_on=['adc_prescaler', 'trigger_device', 'downsample_bits']) sample_rate_chan = traits.Property(label='each channel', depends_on=['sample_rate_total', 'AIN0_enabled','AIN1_enabled', 'AIN2_enabled','AIN3_enabled',]) # but useful when plotting/saving data Vcc = traits.Float(3.3) traits_view = View(Group(Group(Item('AIN_running'), Item( 'Vcc', tooltip=('This does not set Vcc on the AT90USBKEY. Use to record the ' 'value of Vcc. (default = 3.3V)')), orientation='horizontal'), Group(Item('AIN0_enabled',padding=0), Item('AIN0_name',padding=0), Item('AIN1_enabled',padding=0), Item('AIN1_name',padding=0), padding=0, orientation='horizontal'), Group(Item('AIN2_enabled',padding=0), Item('AIN2_name',padding=0), Item('AIN3_enabled',padding=0), Item('AIN3_name',padding=0), padding=0, orientation='horizontal'), Group(Item('adc_prescaler'), Item('downsample_bits'), orientation='horizontal'), Group(Item('sample_rate_total', #show_label=False, style='readonly', ), Item('sample_rate_chan', #show_label=False, style='readonly', ), orientation='horizontal'), )) @traits.cached_property def _get_sample_rate_total(self): if self.trigger_device is not None: input_frequency = self.trigger_device.FOSC/self.adc_prescaler else: input_frequency = 100*1e3 # fake value # from USBKEY datasheet: if input_frequency < 50*1e3: warnings.warn('ADC sample frequency is too slow to get good sampling') if input_frequency > 200*1e3: warnings.warn('ADC sample frequency is too fast to get good sampling') #print 'input_frequency %.1f (kHz)'%(input_frequency/1000.0,) clock_cycles_per_sample = 13.0 clock_adc = input_frequency/clock_cycles_per_sample downsample_factor = self.downsample_bits+1 downsampled_clock_adc = clock_adc/downsample_factor return downsampled_clock_adc @traits.cached_property def _get_sample_rate_chan(self): n_chan = sum(map(int,[self.AIN0_enabled,self.AIN1_enabled, self.AIN2_enabled,self.AIN3_enabled])) if n_chan == 0: return 0.0 rate = self.sample_rate_total/float(n_chan) return rate
inputTemplateModel = File( exists = "True",argstr = "--inputTemplateModel %s") inputLLSModel = File( exists = "True",argstr = "--inputLLSModel %s") inputEPCAModelMat = File( exists = "True",argstr = "--inputEPCAModelMat %s") inputEPCAModelTxt = File( exists = "True",argstr = "--inputEPCAModelTxt %s") inputVolume = File( exists = "True",argstr = "--inputVolume %s") outputVolume = traits.Either(traits.Bool, File, argstr = "--outputVolume %s") outputResampledVolume = traits.Either(traits.Bool, File, argstr = "--outputResampledVolume %s") outputTransform = traits.Either(traits.Bool, File, argstr = "--outputTransform %s") outputLandmarksInInputSpace = traits.Either(traits.Bool, File, argstr = "--outputLandmarksInInputSpace %s") outputLandmarksInACPCAlignedSpace = traits.Either(traits.Bool, File, argstr = "--outputLandmarksInACPCAlignedSpace %s") inputLandmarksPaired = File( exists = "True",argstr = "--inputLandmarksPaired %s") outputLandmarksPaired = traits.Either(traits.Bool, File, argstr = "--outputLandmarksPaired %s") outputMRML = traits.Either(traits.Bool, File, argstr = "--outputMRML %s") outputVerificationScript = traits.Either(traits.Bool, File, argstr = "--outputVerificationScript %s") mspQualityLevel = traits.Int( argstr = "--mspQualityLevel %d") otsuPercentileThreshold = traits.Float( argstr = "--otsuPercentileThreshold %f") acLowerBound = traits.Float( argstr = "--acLowerBound %f") cutOutHeadInOutputVolume = traits.Bool( argstr = "--cutOutHeadInOutputVolume ") outputUntransformedClippedVolume = traits.Either(traits.Bool, File, argstr = "--outputUntransformedClippedVolume %s") rescaleIntensities = traits.Bool( argstr = "--rescaleIntensities ") trimRescaledIntensities = traits.Float( argstr = "--trimRescaledIntensities %f") rescaleIntensitiesOutputRange = traits.List("traits.Int", sep = ",",argstr = "--rescaleIntensitiesOutputRange %d") backgroundFillValueString = traits.Str( argstr = "--BackgroundFillValue %s") interpolationMode = traits.Enum("NearestNeighbor","Linear","ResampleInPlace","BSpline","WindowedSinc", argstr = "--interpolationMode %s") forceACPoint = traits.List("traits.Float", sep = ",",argstr = "--forceACPoint %f") forcePCPoint = traits.List("traits.Float", sep = ",",argstr = "--forcePCPoint %f") forceVN4Point = traits.List("traits.Float", sep = ",",argstr = "--forceVN4Point %f") forceRPPoint = traits.List("traits.Float", sep = ",",argstr = "--forceRPPoint %f") inputLandmarksEMSP = File( exists = "True",argstr = "--inputLandmarksEMSP %s") forceHoughEyeDetectorReportFailure = traits.Bool( argstr = "--forceHoughEyeDetectorReportFailure ") radiusMPJ = traits.Float( argstr = "--rmpj %f")
class major(TConfig): size = T.Float(4) pad = T.Float(4)
class QuadMeshSmoothingInputSpec(CommandLineInputSpec): inputSurface = traits.Str( argstr = "----inputSurface %s") numberOfIterations = traits.Int( argstr = "--numberOfIterations %d") relaxationFactor = traits.Float( argstr = "--relaxationFactor %f") delaunayConforming = traits.Bool( argstr = "----delaunayConforming ") outputSurface = traits.Str( argstr = "----outputSurface %s")
class minor(TConfig): size = T.Float(2) pad = T.Float(4)
class DataAxis(t.HasTraits): name = t.Str() units = t.Str() scale = t.Float() offset = t.Float() size = t.Int() index_in_array = t.Int() low_value = t.Float() high_value = t.Float() value = t.Range('low_value', 'high_value') low_index = t.Int(0) high_index = t.Int() slice = t.Instance(slice) slice_bool = t.Bool(False) index = t.Range('low_index', 'high_index') axis = t.Array() def __init__(self, size, index_in_array, name='', scale=1., offset=0., units='undefined', slice_bool=False): super(DataAxis, self).__init__() self.name = name self.units = units self.scale = scale self.offset = offset self.size = size self.high_index = self.size - 1 self.low_index = 0 self.index = 0 self.index_in_array = index_in_array self.update_axis() self.on_trait_change(self.update_axis, ['scale', 'offset', 'size']) self.on_trait_change(self.update_value, 'index') self.on_trait_change(self.set_index_from_value, 'value') self.on_trait_change(self._update_slice, 'slice_bool') self.on_trait_change(self.update_index_bounds, 'size') self.slice_bool = slice_bool def __repr__(self): if self.name is not None: return self.name + ' index: ' + str(self.index_in_array) def update_index_bounds(self): self.high_index = self.size - 1 def update_axis(self): self.axis = generate_axis(self.offset, self.scale, self.size) self.low_value, self.high_value = self.axis.min(), self.axis.max() # self.update_value() def _update_slice(self, value): if value is True: self.slice = slice(None) else: self.slice = None def get_axis_dictionary(self): adict = { 'name': self.name, 'scale': self.scale, 'offset': self.offset, 'size': self.size, 'units': self.units, 'index_in_array': self.index_in_array, 'slice_bool': self.slice_bool } return adict def update_value(self): self.value = self.axis[self.index] def value2index(self, value): """Return the closest index to the given value if between the limits, otherwise it will return either the upper or lower limits Parameters ---------- value : float Returns ------- int """ if value is None: return None else: index = int(round((value - self.offset) / \ self.scale)) if self.size > index >= 0: return index elif index < 0: messages.warning("The given value is below the axis limits") return 0 else: messages.warning("The given value is above the axis limits") return int(self.size - 1) def index2value(self, index): return self.axis[index] def set_index_from_value(self, value): self.index = self.value2index(value) # If the value is above the limits we must correct the value self.value = self.index2value(self.index) def calibrate(self, value_tuple, index_tuple, modify_calibration=True): scale = (value_tuple[1] - value_tuple[0]) /\ (index_tuple[1] - index_tuple[0]) offset = value_tuple[0] - scale * index_tuple[0] if modify_calibration is True: self.offset = offset self.scale = scale else: return offset, scale traits_view = \ tui.View( tui.Group( tui.Group( tui.Item(name = 'name'), tui.Item(name = 'size', style = 'readonly'), tui.Item(name = 'index_in_array', style = 'readonly'), tui.Item(name = 'index'), tui.Item(name = 'value', style = 'readonly'), tui.Item(name = 'units'), tui.Item(name = 'slice_bool', label = 'slice'), show_border = True,), tui.Group( tui.Item(name = 'scale'), tui.Item(name = 'offset'), label = 'Calibration', show_border = True,), label = "Data Axis properties", show_border = True,), )
class grid(TConfig): color = T.Trait('black', mplT.ColorHandler()) linestyle = T.Trait(':', '-', '--', '-.', ':', 'steps', '', ' ') linewidth = T.Float(0.5)
class patch(TConfig): linewidth = T.Float(1.0) facecolor = T.Trait('blue', mplT.ColorHandler()) edgecolor = T.Trait('black', mplT.ColorHandler()) antialiased = T.true
class DeviceModel(traits.HasTraits): """Represent the trigger device in the host computer, and push any state We keep a local copy of the state of the device in memory on the host computer, and any state changes to the device to through this class, also allowing us to update our copy of the state. """ # Private runtime details _libusb_handle = traits.Any(None,transient=True) _lock = traits.Any(None,transient=True) # lock access to the handle real_device = traits.Bool(False,transient=True) # real USB device present FOSC = traits.Float(8000000.0,transient=True) ignore_version_mismatch = traits.Bool(False, transient=True) # A couple properties frames_per_second = RemoteFpsFloat frames_per_second_actual = traits.Property(depends_on='_t3_state') timer3_top = traits.Property(depends_on='_t3_state') # Timer 3 state: _t3_state = traits.Instance(DeviceTimer3State) # atomic updates # LEDs state _led_state = traits.Int led1 = traits.Property(depends_on='_led_state') led2 = traits.Property(depends_on='_led_state') led3 = traits.Property(depends_on='_led_state') led4 = traits.Property(depends_on='_led_state') # Event would be fine for these, but use Button to get nice editor reset_framecount_A = traits.Button reset_AIN_overflow = traits.Button do_single_frame_pulse = traits.Button ext_trig1 = traits.Button ext_trig2 = traits.Button ext_trig3 = traits.Button # Analog input state: _ain_state = traits.Instance(DeviceAnalogInState) # atomic updates Vcc = traits.Property(depends_on='_ain_state') AIN_running = traits.Property(depends_on='_ain_state') enabled_channels = traits.Property(depends_on='_ain_state') enabled_channel_names = traits.Property(depends_on='_ain_state') # The view: traits_view = View(Group( Group(Item('frames_per_second', label='frame rate', ), Item('frames_per_second_actual', show_label=False, style='readonly', ), orientation='horizontal',), Group(Item('ext_trig1',show_label=False), Item('ext_trig2',show_label=False), Item('ext_trig3',show_label=False), orientation='horizontal'), Item('_ain_state',show_label=False, style='custom'), Item('reset_AIN_overflow',show_label=False), )) def __init__(self,*a,**k): super(DeviceModel,self).__init__(*a,**k) self._t3_state = DeviceTimer3State() self._ain_state = DeviceAnalogInState(trigger_device=self) def __new__(cls,*args,**kwargs): """Set the transient object state This must be done outside of __init__, because instances can get created without calling __init__. In particular, when being loaded from a pickle. """ self = super(DeviceModel, cls).__new__(cls,*args,**kwargs) self._lock = threading.Lock() self._open_device() # force the USBKEY's state to our idea of its state self.__led_state_changed() self.__t3_state_changed() self.__ain_state_changed() self.reset_AIN_overflow = True # reset ain overflow #self.rand_pulse_enable() #self.rand_pulse_disable() #self.set_aout_values(300,250) return self def _set_led_mask(self,led_mask,value): if value: self._led_state = self._led_state | led_mask else: self._led_state = self._led_state & ~led_mask def __led_state_changed(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_SET_LED_STATE) buf[1] = chr(self._led_state) self._send_buf(buf) @traits.cached_property def _get_led1(self): return bool(self._led_state & LEDS_LED1) def _set_led1(self,value): self._set_led_mask(LEDS_LED1,value) @traits.cached_property def _get_led2(self): return bool(self._led_state & LEDS_LED2) def _set_led2(self,value): self._set_led_mask(LEDS_LED2,value) @traits.cached_property def _get_led3(self): return bool(self._led_state & LEDS_LED3) def _set_led3(self,value): self._set_led_mask(LEDS_LED3,value) @traits.cached_property def _get_led4(self): return bool(self._led_state & LEDS_LED4) def _set_led4(self,value): self._set_led_mask(LEDS_LED4,value) @traits.cached_property def _get_Vcc(self): return self._ain_state.Vcc @traits.cached_property def _get_AIN_running(self): return self._ain_state.AIN_running @traits.cached_property def _get_enabled_channels(self): result = [] if self._ain_state.AIN0_enabled: result.append(0) if self._ain_state.AIN1_enabled: result.append(1) if self._ain_state.AIN2_enabled: result.append(2) if self._ain_state.AIN3_enabled: result.append(3) return result @traits.cached_property def _get_enabled_channel_names(self): result = [] if self._ain_state.AIN0_enabled: result.append(self._ain_state.AIN0_name) if self._ain_state.AIN1_enabled: result.append(self._ain_state.AIN1_name) if self._ain_state.AIN2_enabled: result.append(self._ain_state.AIN2_name) if self._ain_state.AIN3_enabled: result.append(self._ain_state.AIN3_name) return result @traits.cached_property def _get_timer3_top(self): return self._t3_state.timer3_top @traits.cached_property def _get_frames_per_second_actual(self): if self._t3_state.timer3_CS==0: return 0 return self.FOSC/self._t3_state.timer3_CS/self._t3_state.timer3_top def set_frames_per_second_approximate(self,value): """Set the framerate as close as possible to the desired value""" new_t3_state = DeviceTimer3State() if value==0: new_t3_state.timer3_CS=0 else: # For all possible clock select values CSs = np.array([1.0,8.0,64.0,256.0,1024.0]) # find the value of top that to gives the desired framerate best_top = np.clip(np.round(self.FOSC/CSs/value),0,2**16-1).astype(np.int) # and find the what the framerate would be at that top value best_rate = self.FOSC/CSs/best_top # and choose the best one. idx = np.argmin(abs(best_rate-value)) expected_rate = best_rate[idx] new_t3_state.timer3_CS = CSs[idx] new_t3_state.timer3_top = best_top[idx] ideal_ocr3a = 0.02 * new_t3_state.timer3_top # 2% duty cycle ocr3a = int(np.round(ideal_ocr3a)) if ocr3a==0: ocr3a=1 if ocr3a >= new_t3_state.timer3_top: ocr3a-=1 if ocr3a <= 0: raise ValueError('impossible combination for ocr3a') new_t3_state.ocr3a = ocr3a self._t3_state = new_t3_state # atomic update def get_framestamp(self,full_output=False): """Get the framestamp and the value of PORTC The framestamp includes fraction of IFI until next frame. The inter-frame counter counts up from 0 to self.timer3_top between frame ticks. """ if not self.real_device: now = time.time() if full_output: framecount = now//1 tcnt3 = now%1.0 results = now, framecount, tcnt3 else: results = now return results buf = ctypes.create_string_buffer(1) buf[0] = chr(CAMTRIG_GET_FRAMESTAMP_NOW) self._send_buf(buf) data = self._read_buf() if data is None: raise NoDataError('no data available from device') framecount = 0 for i in range(8): framecount += ord(data[i]) << (i*8) tcnt3 = ord(data[8]) + (ord(data[9]) << 8) frac = tcnt3/float(self._t3_state.timer3_top) if frac>1: print('In ttriger.DeviceModel.get_framestamp(): ' 'large fractional value in framestamp. resetting') frac=1 framestamp = framecount+frac # WBD #if full_output: # results = framestamp, framecount, tcnt3 #else: # results = framestamp pulse_width = ord(data[10]) if full_output: results = framestamp, pulse_width, framecount, tcnt3 else: results = framestamp, pulse_width return results def get_analog_input_buffer_rawLE(self): if not self.real_device: outbuf = np.array([],dtype='<u2') # unsigned 2 byte little endian return outbuf EP_LEN = 256 INPUT_BUFFER = ctypes.create_string_buffer(EP_LEN) bufs = [] got_bytes = False timeout = 50 # msec cnt = 0 # Count number of times endpoint has been read min_cnt = 2 # Minimum number of times end point should be read while 1: # keep pumping until no more data try: with self._lock: n_bytes = usb.bulk_read(self._libusb_handle, (ENDPOINT_DIR_IN|ANALOG_EPNUM), INPUT_BUFFER, timeout) except usb.USBNoDataAvailableError: break cnt += 1 n_elements = n_bytes//2 buf = np.fromstring(INPUT_BUFFER.raw,dtype='<u2') # unsigned 2 byte little endian buf = buf[:n_elements] bufs.append(buf) if (n_bytes < EP_LEN) and (cnt >= min_cnt): break # don't bother waiting for data to dribble in if len(bufs): outbuf = np.hstack(bufs) else: outbuf = np.array([],dtype='<u2') # unsigned 2 byte little endian return outbuf def __t3_state_changed(self): # A value was assigned to self._t3_state. # 1. Send its contents to device self._send_t3_state() # 2. Ensure updates to it also get sent to device if self._t3_state is None: return self._t3_state.on_trait_change(self._send_t3_state) def _send_t3_state(self): """ensure our concept of the device's state is correct by setting it""" t3 = self._t3_state # shorthand if t3 is None: return buf = ctypes.create_string_buffer(10) buf[0] = chr(CAMTRIG_NEW_TIMER3_DATA) buf[1] = chr(t3.ocr3a//0x100) buf[2] = chr(t3.ocr3a%0x100) buf[3] = chr(t3.ocr3b//0x100) buf[4] = chr(t3.ocr3b%0x100) buf[5] = chr(t3.ocr3c//0x100) buf[6] = chr(t3.ocr3c%0x100) buf[7] = chr(t3.timer3_top//0x100) # icr3a buf[8] = chr(t3.timer3_top%0x100) # icr3a buf[9] = chr(t3.timer3_CS_) self._send_buf(buf) def __ain_state_changed(self): # A value was assigned to self._ain_state. # 1. Send its contents to device self._send_ain_state() # 2. Ensure updates to it also get sent to device if self._ain_state is None: return self._ain_state.on_trait_change(self._send_ain_state) def _send_ain_state(self): """ensure our concept of the device's state is correct by setting it""" ain_state = self._ain_state # shorthand if ain_state is None: return if ain_state.AIN_running: # analog_cmd_flags channel_list = 0 if ain_state.AIN0_enabled: channel_list |= ENABLE_ADC_CHAN0 if ain_state.AIN1_enabled: channel_list |= ENABLE_ADC_CHAN1 if ain_state.AIN2_enabled: channel_list |= ENABLE_ADC_CHAN2 if ain_state.AIN3_enabled: channel_list |= ENABLE_ADC_CHAN3 analog_cmd_flags = ADC_START_STREAMING | channel_list analog_sample_bits = ain_state.adc_prescaler_ | (ain_state.downsample_bits<<3) else: analog_cmd_flags = ADC_STOP_STREAMING analog_sample_bits = 0 buf = ctypes.create_string_buffer(3) buf[0] = chr(CAMTRIG_AIN_SERVICE) buf[1] = chr(analog_cmd_flags) buf[2] = chr(analog_sample_bits) self._send_buf(buf) def enter_dfu_mode(self): buf = ctypes.create_string_buffer(1) buf[0] = chr(CAMTRIG_ENTER_DFU) self._send_buf(buf) def _do_single_frame_pulse_fired(self): buf = ctypes.create_string_buffer(1) buf[0] = chr(CAMTRIG_DO_TRIG_ONCE) self._send_buf(buf) def _ext_trig1_fired(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_SET_EXT_TRIG) buf[1] = chr(EXT_TRIG1) self._send_buf(buf) def _ext_trig2_fired(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_SET_EXT_TRIG) buf[1] = chr(EXT_TRIG2) self._send_buf(buf) def _ext_trig3_fired(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_SET_EXT_TRIG) buf[1] = chr(EXT_TRIG3) self._send_buf(buf) def _reset_framecount_A_fired(self): buf = ctypes.create_string_buffer(1) buf[0] = chr(CAMTRIG_RESET_FRAMECOUNT_A) self._send_buf(buf) def _reset_AIN_overflow_fired(self): buf = ctypes.create_string_buffer(3) buf[0] = chr(CAMTRIG_AIN_SERVICE) buf[1] = chr(ADC_RESET_AIN) # 3rd byte doesn't matter self._send_buf(buf) # WBD - functions for enabling and disabling random pulses # -------------------------------------------------------- def rand_pulse_enable(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_RAND_PULSE) buf[1] = chr(RAND_PULSE_ENABLE) self._send_buf(buf) def rand_pulse_disable(self): buf = ctypes.create_string_buffer(2) buf[0] = chr(CAMTRIG_RAND_PULSE) buf[1] = chr(RAND_PULSE_DISABLE) self._send_buf(buf) # WBD - function for setting analog output values # ------------------------------------------------------- def set_aout_values(self,val0, val1): buf = ctypes.create_string_buffer(5) buf[0] = chr(CAMTRIG_SET_AOUT) buf[1] = chr(val0//0x100) buf[2] = chr(val0%0x100) buf[3] = chr(val1//0x100) buf[4] = chr(val1%0x100) self._send_buf(buf) # WBD - get pulse width from frame count # ------------------------------------------------------- def get_width_from_framecnt(self,framecnt): buf = ctypes.create_string_buffer(5) buf[0] = chr(CAMTRIG_GET_PULSE_WIDTH) for i in range(1,5): buf[i] = chr((framecnt >> ((i-1)*8)) & 0b11111111) self._send_buf(buf) data = self._read_buf() val = ord(data[0]) return val # WBD - modified read_buf functions for multiple epnum in buffers # --------------------------------------------------------------- def _read_buf(self): if not self.real_device: return None buf = ctypes.create_string_buffer(16) timeout = 1000 epnum = (ENDPOINT_DIR_IN|CAMTRIG_EPNUM) with self._lock: try: val = usb.bulk_read(self._libusb_handle, epnum, buf, timeout) except usb.USBNoDataAvailableError: return None return buf # --------------------------------------------------------------- def _send_buf(self,buf): if not self.real_device: return with self._lock: val = usb.bulk_write(self._libusb_handle, 0x06, buf, 9999) def _open_device(self): require_trigger = int(os.environ.get('REQUIRE_TRIGGER','1')) if require_trigger: usb.init() if not usb.get_busses(): usb.find_busses() usb.find_devices() busses = usb.get_busses() found = False for bus in busses: for dev in bus.devices: debug('idVendor: 0x%04x idProduct: 0x%04x'% (dev.descriptor.idVendor,dev.descriptor.idProduct)) if (dev.descriptor.idVendor == 0x1781 and dev.descriptor.idProduct == 0x0BAF): found = True break if found: break if not found: raise RuntimeError("Cannot find device. (Perhaps run with " "environment variable REQUIRE_TRIGGER=0.)") else: self.real_device = False return with self._lock: self._libusb_handle = usb.open(dev) manufacturer = usb.get_string_simple(self._libusb_handle,dev.descriptor.iManufacturer) product = usb.get_string_simple(self._libusb_handle,dev.descriptor.iProduct) serial = usb.get_string_simple(self._libusb_handle,dev.descriptor.iSerialNumber) assert manufacturer == 'Strawman', 'Wrong manufacturer: %s'%manufacturer valid_product = 'Camera Trigger 1.0' if product == valid_product: self.FOSC = 8000000.0 elif product.startswith('Camera Trigger 1.01'): osc_re = r'Camera Trigger 1.01 \(F_CPU = (.*)\)\w*' match = re.search(osc_re,product) fosc_str = match.groups()[0] if fosc_str.endswith('UL'): fosc_str = fosc_str[:-2] self.FOSC = float(fosc_str) else: errmsg = 'Expected product "%s", but you have "%s"'%( valid_product,product) if self.ignore_version_mismatch: print 'WARNING:',errmsg self.FOSC = 8000000.0 print ' assuming FOSC=',self.FOSC else: raise ValueError(errmsg) interface_nr = 0 if hasattr(usb,'get_driver_np'): # non-portable libusb extension name = usb.get_driver_np(self._libusb_handle,interface_nr) if name != '': usb.detach_kernel_driver_np(self._libusb_handle,interface_nr) if dev.descriptor.bNumConfigurations > 1: debug("WARNING: more than one configuration, choosing first") config = dev.config[0] usb.set_configuration(self._libusb_handle, config.bConfigurationValue) usb.claim_interface(self._libusb_handle, interface_nr) self.real_device = True