koronascript 0.1__tar.gz

koronascript-0.1/KoronaScript/Configuration.py

@@ -0,0 +1,3 @@
+# Auto-generated, do not edit directly
+# see genmodule.py
+modules_spec = {'AngleDeletion': {'Active': True, 'Comment': ''}, 'BroadbandNotchFilter': {'Active': True, 'Comment': ''}, 'BroadbandSplitter': {'Active': True, 'Comment': '', 'AutoSplit': False, 'SplitCount': 3, 'StopBandDistance': 1.0, 'MinBandwidth': 10.0, 'Downsampling': 'FACTOR', 'DownsamplingFactor': 1, 'DownsamplingSampleSize': 0.01, 'ComputeAngles': True, 'ComputationalMethod': 'BANDPASS_FILTERING', 'FftWindowSize': 2.0}, 'BubblSpikeFilter': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': False, 'StartDepth': 10.0, 'EndDepth': 2500.0, 'TotalDelta': 15.0, 'VerticalDelta': 15.0, 'Debug': False, 'VerticalUnit': 'DURATION', 'VerticalMedianSearchHeight': 50, 'WindowMedianSearchHeight': 35, 'VerticalMedianSearchDuration': 2.0, 'WindowMedianSearchDuration': 4.4, 'VerticalMedianSearchDistance': 1.9, 'WindowMedianSearchDistance': 6.6}, 'Categorization': {'Active': True, 'Comment': '', 'CategoryCount': 3, 'ActiveFeatures': [], 'ActiveCategories': [], 'Categorizer': 'Gauss', 'Discriminant': 'Aposteriori', 'ContextualCorrection': 'ICM', 'ContextualIterations': 3, 'UseMinLogSv': True, 'MinLogSv': -100.0}, 'CdsViewer': {'Active': True, 'Comment': ''}, 'ChannelDataRemoval': {'Active': True, 'Comment': '', 'Channels': '', 'ChannelsFromEnd': '', 'Frequencies': '', 'KeepSpecified': False}, 'ChannelRemoval': {'Active': True, 'Comment': '', 'Channels': '', 'ChannelsFromEnd': '', 'Frequencies': '', 'KeepSpecified': False}, 'Combination': {'Active': True, 'Comment': '', 'FirstOperandKhz': 0, 'SecondOperandKhz': 0, 'FirstOperandChannel': 1, 'SecondOperandChannel': 2, 'LogarithmicOperands': False, 'Operation': 'mean'}, 'Comment': {'Active': True, 'Comment': '', 'GroupStart': False, 'GroupCollapsed': False, 'LineBreak': False, 'VerticalSpace': 8, 'Label': ''}, 'ComplexToReal': {'Active': True, 'Comment': '', 'ComputeAngles': True, 'KeepBroadband': False}, 'DataReduction': {'Active': True, 'Comment': '', 'BlindZone': False, 'MinRange': '', 'MinDepth': '', 'TransducerRange': True, 'MaxRange': '', 'MaxDepth': ''}, 'DepthDependentResampling': {'Active': True, 'Comment': '', 'MinFrequency': 150.0, 'SampleDistanceAtRange100': 0.0}, 'Depth': {'Active': True, 'Comment': '', 'Algorithm': 'EK500', 'MinDepthLimit': 10.0, 'MinDepthValueFraction': 0.001, 'SignalStrengthThreshold': -31.0, 'MinimumDepthThresholdFactor': 0.99, 'MaxRangeFactor': 1.5, 'AlwaysDetectBottom': True, 'MinBottomDepth': 0.0, 'MaxBottomDepth': 9999.0, 'MinKHz': 0.0, 'MaxKHz': 9999.0, 'DoNotUseKHz': ''}, 'Dilate': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'VertResolution': 1}, 'Downsampling': {'Active': True, 'Comment': '', 'Downsampling': 'FACTOR', 'DownsamplingFactor': 1, 'DownsamplingSampleSize': 0.01}, 'ES60Correction': {'Active': True, 'Comment': '', 'ReliabilityDetectionWindow': 5, 'PerformScan': False, 'ContinueAcrossFiles': False}, 'EdgeDetection': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'ScaleFactor': 1.0, 'VertResolution': 1}, 'EmptyPingRemoval': {'Active': True, 'Comment': ''}, 'ErodeLowValues': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'Threshold': -70.0, 'ReplacementValue': -120.0, 'VerticalExtent': 1.0}, 'Erode': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'VertResolution': 1}, 'Expression': {'Active': True, 'Comment': '', 'Expression': ['C1']}, 'FillMissingData': {'Active': True, 'Comment': ''}, 'Filter3X3': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'FilterType': 'User defined', '00': 1.0, '01': 1.0, '02': 1.0, '10': 1.0, '11': 1.0, '12': 1.0, '20': 1.0, '21': 1.0, '22': 1.0}, 'FiskViewDisplay': {'Active': True, 'Comment': ''}, 'GroupEnd': {'Active': True, 'Comment': ''}, 'HorizontalOffsetCorrection': {'Active': True, 'Comment': ''}, 'Isolation': {'Active': True, 'Comment': '', 'Category': ''}, 'Median': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0}, 'NoiseAcceptance': {'Active': True, 'Comment': '', 'NoiseFraction': {'min': 0.25, 'max': 4.0}, 'UseFileNoiseFile': True, 'UseDayNoiseFile': True, 'UseSurveyNoiseFile': True, 'UseSurveyLowNoiseFile': True}, 'NoiseMedianQuantification': {'Active': True, 'Comment': '', 'PingHistory': 10, 'NoiseSamplesPerBeam': 100, 'DetectionDistance': 50.0, 'InnermostDistance': False}, 'NoiseQuantification': {'Active': True, 'Comment': '', 'Smooth': 'running averager', 'SmoothInterval': 5, 'Mask': 'dynamic', 'MinimumQuality': 60.0, 'ThresholdMasking': False, 'Threshold': -80.0, 'Histogram': 'geometric', 'UseTimeStepBuffer': True, 'TimeStepBufferMaxSize': 50, 'HistogramInitializationCellCount': 500, 'HistogramMaximumCellCount': 2000, 'HistogramInitializationSampleCount': 1000, 'HistogramMinimumSampleCount': 25000, 'HistogramSmooth': True, 'HistogramSmoothFactor': 100.0, 'SdevMasking': False, 'Sdev': 10.0, 'SNMasking': False, 'SNRatio': 10.0, 'UseFallbackNoiseQuantile': False, 'FallbackNoiseQuantile': 5.0, 'FallbackNoiseChannels': 'true', 'WritePlotParameters': False}, 'NoiseRemover': {'Active': True, 'Comment': '', 'RemoveNoiseFromStart': True, 'MaxBufferSize': 10}, 'NoiseVisualization': {'Active': True, 'Comment': '', 'UpdatePeriod': 20, 'TimeSeriesLength': 200, 'HistogramSpan': 3.0, 'MedianSampleCount': 500}, 'PingCollapsing': {'Active': True, 'Comment': ''}, 'PingThinning': {'Active': True, 'Comment': '', 'PingsToSkipInitially': 0, 'PingsToSkip': 0}, 'PlanktonInversion': {'Active': True, 'Comment': '', 'VerticalUnit': 'SAMPLES', 'PingsPerBin': 7, 'DepthSamplesPerBin': 30, 'DepthDurationPerBin': 4.0, 'DepthDistancePerBin': 6.0, 'Use global noise threshold': True, 'Noise threshold': -90.0, 'Use min depth': False, 'Min depth': 20.0, 'Use max depth': False, 'Max depth': 110.0, 'CategoriesUsedForInversion': [], 'UseAllFrequencies': True, 'ActiveFrequencies': [], 'MinResidualErrorThreshold': 0.01, 'MaxResidualErrorThreshold': 0.2, 'LevenbergMarquardtFactor': 0.0005, 'MaxIter': 4, 'HardShelled': True, 'HardShelledR': 0.5, 'GaseousSphere': True, 'GasSphereG': 0.0012, 'GasSphereH': 0.22, 'FluidSpheriod': True, 'FluidSpheriodG': 1.043, 'FluidSpheriodH': 1.052, 'FluidSpheriodBeta': 5.0, 'FluidBent': True, 'FluidBentR': 0.058, 'FluidBentS': 0.1, 'FluidBentBeta': 11.0, 'FluidBent2': False, 'FluidBentR2': 0.058, 'FluidBentS2': 0.1, 'FluidBentBeta 2': 11.0, 'SDWBA': False, 'SDWBA coeff': 'N(0, 30)', 'SDWBA2': False, 'SDWBA 2 coeff': 'N(0, 30)', 'SDWBA3': False, 'SDWBA 3 coeff': 'N(0, 30)', 'SDWBA4': False, 'SDWBA 4 coeff': 'N(0, 30)', 'SDWBA5': False, 'SDWBA 5 coeff': 'N(0, 30)', 'SDWBAS': False, 'SDWBA smooth coeff': 'N(4, 2)', 'PlotResolution': 0.01, 'PlotMaxRange': 5.0}, 'Plugin': {'Active': True, 'Comment': '', 'Example': '', 'Implementation': ''}, 'PulseCompressionFilter': {'Active': True, 'Comment': ''}, 'RemoveBottom': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'UseNeighbours': False, 'Above': 0, 'Below': 100, 'RemoveAboveBottom': False, 'RemoveBottom': True, 'RemoveBelowBottom': False, 'PixelValue': -120.0}, 'Rescale': {'Active': True, 'Comment': '', 'RescaleChannels': 'all', 'DesiredMinimum': -85.0, 'DesiredMaximum': -30.0, 'MinMaxFraction': 0.05, 'InitializationDatagramCount': 10, 'InitializationMaxPingCount': 100}, 'SchoolCategorization': {'Active': True, 'Comment': '', 'UseCellCategorization': True, 'Horizontal cell size': 16, 'Vertical cell size': 50, 'Upper sample offset': 5, 'Lower sample offset': 5, 'HorizontalOffset': 0, 'SecondaryCategoryFraction': 0.1, 'Fill factor for cells': 0.5, 'MinFractionCategorizedCells': 0.5, 'MinCells': 3, 'SchoolCategorizationDistribution': 'CELL', 'EnableUncategorizedCategory': False, 'EnableUnknownCategory': False}, 'SchoolDetection': {'Active': True, 'Comment': '', 'ProcessLast': True, 'Channel': 1, 'MinDepth': '', 'MaxDepth': '', 'Threshold': -62.0, 'Density': {'min': -120.0, 'max': -20.0}, 'MaxSv': {'min': '-Infinity', 'max': 'Infinity'}, 'Length': {'min': 25.0, 'max': 1000000.0}, 'Thickness': {'min': 10.0, 'max': 1000000.0}, 'Area': {'min': 75.0, 'max': 1000000.0}, 'Compactness': {'min': '-Infinity', 'max': 'Infinity'}, 'FillHoles': True}, 'Smoother': {'Active': True, 'Comment': '', 'OnlyLastChannel': False, 'MaskPelagic': False, 'MaskBottom': True, 'MaskSecondBottom': True, 'MaskNoise': False, 'MaskRegion': 'none', 'MaskTrack': 'none', 'MinPing': 0, 'MaxPing': 10, 'HorizontalKernelType': 'gaussian', 'VerticalKernelType': 'gaussian', 'HorizontalWidth': 8.0, 'VerticalWidth': 0.5, 'LogarithmicValues': False}, 'SpikeFilter': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': False, 'StartDepth': 10.0, 'EndDepth': 2500.0, 'TotalDelta': 15.0, 'VerticalDelta': 15.0, 'Debug': False, 'VerticalUnit': 'DURATION', 'VerticalMedianSearchHeight': 7, 'WindowMedianSearchHeight': 35, 'VerticalMedianSearchDuration': 0.9, 'WindowMedianSearchDuration': 4.4, 'VerticalMedianSearchDistance': 1.3, 'WindowMedianSearchDistance': 6.6}, 'SpotNoise': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': False, 'StartDepth': 10.0, 'EndDepth': 2500.0, 'Delta': 20.0, 'Debug': False}, 'TemporaryComputationsBegin': {'Active': True, 'Comment': ''}, 'TemporaryComputationsEnd': {'Active': True, 'Comment': ''}, 'ThresholdAllChannels': {'Active': True, 'Comment': '', 'Criterion': 'BELOW', 'Threshold': -70.0, 'Replacement': -120.0, 'MinFrequency': '', 'MaxFrequency': ''}, 'Threshold': {'Active': True, 'Comment': '', 'LogarithmicValues': True, 'ShowDetails': False, 'OnlyLast': False, 'ChannelsToProcess': -1, 'AutomaticDepthRange': True, 'StartDepth': 10.0, 'EndDepth': 1000.0, 'Threshold': -70.0, 'CutBelow': False, 'CutAbove': False, 'BelowVal': -120.0, 'AboveVal': 0.0}, 'TimeInterval': {'Active': True, 'Comment': '', 'StartDateString': '', 'EndDateString': '', 'StartRelativePingNumber': '', 'EndRelativePingNumber': ''}, 'Towfish': {'Active': True, 'Comment': '', 'TowfishBlindZone': 0.0, 'TowfishEchosounderTimeAddition': 0.0, 'DistBehindFunction': 'PYTAGORAS'}, 'TrackFilter': {'Active': True, 'Comment': '', 'MaxBufferSize': 50, 'KeepValid': True}, 'Tracking': {'Active': True, 'Comment': '', 'TrackerType': 'Aggregation', 'kHz': 38, 'PlatformMotionType': 'Floating', 'MinTS': -66.0, 'PulseLengthDeterminationLevel': 6.0, 'MinEchoLength': 0.01, 'MaxEchoLength': 1.8, 'MaxGainCompensation': 6.0, 'DoPhaseDeviationCheck': True, 'MaxPhaseDevSteps': 8.0, 'MaxTS': 0.0, 'MaxDepth': '', 'MaxAlongshipAngle': 10.0, 'MaxAthwartshipAngle': 10.0, 'InitiationGateFunction': [{'id': 'Alpha', 'description': '', 'unit': 'degree', 'defaultValue': 2.8}, {'id': 'Beta', 'description': '', 'unit': 'degree', 'defaultValue': 2.8}, {'id': 'Range', 'description': '', 'unit': 'm', 'defaultValue': 0.1}, {'id': 'TS', 'description': 'dB', 'unit': 'dB', 'defaultValue': 20.0}], 'InitiationMinLength': 1, 'GateFunction': [{'id': 'Alpha', 'description': '', 'unit': 'degree', 'defaultValue': 2.8}, {'id': 'Beta', 'description': '', 'unit': 'degree', 'defaultValue': 2.8}, {'id': 'Range', 'description': '', 'unit': 'm', 'defaultValue': 0.1}, {'id': 'TS', 'description': 'dB', 'unit': 'dB', 'defaultValue': 20.0}], 'AlphaBetaEstimator': [{'id': 'Alpha', 'description': '', 'allowedValuesDescription': '[0, 1]', 'defaultValue': 0.5}, {'id': 'Beta', 'description': '', 'allowedValuesDescription': '[0, 1]', 'defaultValue': 0.5}], 'MaxMissingPings': 4, 'MaxMissingSamples': 2, 'MaxMissingPingsFraction': 0.5, 'MinTrackLength': 8, 'MinSampleToLengthFraction': 2.0}, 'TsDetection': {'Active': True, 'Comment': '', 'DetectorType': 'SED', 'MinTS': -66.0, 'PulseLengthDeterminationLevel': 6.0, 'MinEchoLength': 0.01, 'MaxEchoLength': 1.8, 'MaxGainCompensation': 6.0, 'DoPhaseDeviationCheck': True, 'MaxPhaseDevSteps': 8.0, 'MaxDepth': ''}, 'VerticalOffsetCorrection': {'Active': True, 'Comment': ''}, 'Writer': {'Active': True, 'Comment': '', 'FileName': '', 'UseRelativeDirectory': False, 'RelativeDirectory': '', 'DirectoryName': ''}, 'NetcdfWriter': {'Active': True, 'Comment': '', 'DirName': 'netcdf', 'MainFrequency': 38, 'WriterType': 'GRIDDED', 'DeltaRange': '', 'MaxRange': '', 'GriddedOutputType': 'SV_AND_ANGLES', 'WriteAngels': True, 'FftWindowSize': 2.0, 'DeltaFrequency': 1.0, 'ChannelGroupOutputType': 'PULSE_COMPRESSION'}}

koronascript-0.1/KoronaScript/KoronaModule.py

@@ -0,0 +1,64 @@
+from .Configuration import modules_spec
+
+global_spec = {
+    # 'ModuleConfiguration' : None, # cds file name, attrib 'ref' points to...what?
+    #   <parameter name="ModuleConfiguration" ref="CfsDirectory">CW.cds</parameter>
+    # The following are None, or point to xml files (contents unknown)
+    'Categorization' : None,
+    'HorizontalTransducerOffsets' : None,
+    'VerticalTransducerOffsets' : None,
+    'TransducerRanges' : None,
+    'Plankton' : None,
+    'BroadbandNotchFilters' : None,
+    'PulseCompressionFilters' : None,
+    'BroadbandSplitterBands' : None,
+    'Towfish' : None,
+}
+
+class KoronaModule():
+    '''Baseclass for modules'''
+
+    def __init__(self, name, **parameters):
+        '''initialize with parameter definitions'''
+        # check that the module exists
+        if name not in modules_spec:
+            print(f'Unknown Korona module "{name}" - aborting')
+            exit(-1)
+        self._name = name
+        self._config = {}
+        # Add defaults
+        for k,v in modules_spec[name].items():
+            self._config[k] = v
+
+        for k in parameters:
+            if k != 'Active' and not k in modules_spec[name]:
+                print(f'Parameter "{k}" not valid for Korona module "{name}" - aborting')
+                exit(-1)
+            self._config[k] = parameters[k]
+
+    def to_xml(self):
+        '''Generate XML output'''
+        res = ''
+        myname = self._name + 'Module'
+        res += (f'  <module name="{myname}">\n')
+        res += ('    <parameters>\n')
+        for k in self._config:
+            if self._config[k] is None:
+                res += f'      <parameter name="{k}"/>\n'
+            elif isinstance(self._config[k],list):
+                res += f'      <parameter name="{k}">'
+                for v in self._config[k]:
+                    res += str(v)+','
+                res = res[:-1] # remove last comma
+                res += '</parameter>\n'
+            elif isinstance(self._config[k],dict):
+                res += f'      <parameter name="{k}">\n'
+                # Should maybe call recursively?  Can they be lists or dicts?
+                for key,val in self._config[k].items():
+                    res += f'       <parameter name="{key}">{val}</parameter>\n'
+                res +=  '      </parameter>\n'
+            else:
+                res += (f'      <parameter name="{k}">{self._config[k]}</parameter>\n')
+        res += ('    </parameters>\n')
+        res += ('  </module>\n')
+        return res

koronascript-0.1/KoronaScript/Modules.py

@@ -0,0 +1,295 @@
+# Auto-generated, do not edit directly
+# see genmodule.py
+from .Configuration import modules_spec
+from .KoronaModule import KoronaModule
+
+class AngleDeletion(KoronaModule):
+    """Converts split beam data to single beam data"""
+    def __init__(self, **parameters):
+        super().__init__('AngleDeletion', **parameters)
+
+class BroadbandNotchFilter(KoronaModule):
+    """Applies notch filter(s) to broadband data"""
+    def __init__(self, **parameters):
+        super().__init__('BroadbandNotchFilter', **parameters)
+
+class BroadbandSplitter(KoronaModule):
+    """Splits broadband data into multiple single frequency channels"""
+    def __init__(self, **parameters):
+        super().__init__('BroadbandSplitter', **parameters)
+
+class BubblSpikeFilter(KoronaModule):
+    """Filters bubble spikes"""
+    def __init__(self, **parameters):
+        super().__init__('BubblSpikeFilter', **parameters)
+
+class Categorization(KoronaModule):
+    """Module for categorization"""
+    def __init__(self, **parameters):
+        super().__init__('Categorization', **parameters)
+
+class CdsViewer(KoronaModule):
+    """For viewing the module configuration stored in a processed file"""
+    def __init__(self, **parameters):
+        super().__init__('CdsViewer', **parameters)
+
+class ChannelDataRemoval(KoronaModule):
+    """Removes data on specified channels"""
+    def __init__(self, **parameters):
+        super().__init__('ChannelDataRemoval', **parameters)
+
+class ChannelRemoval(KoronaModule):
+    """Removes specified channels"""
+    def __init__(self, **parameters):
+        super().__init__('ChannelRemoval', **parameters)
+
+class Combination(KoronaModule):
+    """Module for generating combination echograms"""
+    def __init__(self, **parameters):
+        super().__init__('Combination', **parameters)
+
+class Comment(KoronaModule):
+    """For writing a comment"""
+    def __init__(self, **parameters):
+        super().__init__('Comment', **parameters)
+
+class ComplexToReal(KoronaModule):
+    """Converts complex data to real data. (Many modules require real data as input.)"""
+    def __init__(self, **parameters):
+        super().__init__('ComplexToReal', **parameters)
+
+class DataReduction(KoronaModule):
+    """Removes data below configured transducer range"""
+    def __init__(self, **parameters):
+        super().__init__('DataReduction', **parameters)
+
+class DepthDependentResampling(KoronaModule):
+    """Depth dependent resampling"""
+    def __init__(self, **parameters):
+        super().__init__('DepthDependentResampling', **parameters)
+
+class Depth(KoronaModule):
+    """Bottom depth detection module"""
+    def __init__(self, **parameters):
+        super().__init__('Depth', **parameters)
+
+class Dilate(KoronaModule):
+    """A dilation filter.<br>Each pixel gets the value of the max value of its neighbors"""
+    def __init__(self, **parameters):
+        super().__init__('Dilate', **parameters)
+
+class Downsampling(KoronaModule):
+    """Downsampling to reduce vertical resolution"""
+    def __init__(self, **parameters):
+        super().__init__('Downsampling', **parameters)
+
+class ES60Correction(KoronaModule):
+    """Removes the ES60 triangle noise"""
+    def __init__(self, **parameters):
+        super().__init__('ES60Correction', **parameters)
+
+class EdgeDetection(KoronaModule):
+    """Detects edges by using Sobel horizontal and vertical filter"""
+    def __init__(self, **parameters):
+        super().__init__('EdgeDetection', **parameters)
+
+class EmptyPingRemoval(KoronaModule):
+    """Deletes empty pings"""
+    def __init__(self, **parameters):
+        super().__init__('EmptyPingRemoval', **parameters)
+
+class ErodeLowValues(KoronaModule):
+    """Erode values in a spatial surrounding (given by vertical extent) - often used after top thresholding by means of Thresholding module"""
+    def __init__(self, **parameters):
+        super().__init__('ErodeLowValues', **parameters)
+
+class Erode(KoronaModule):
+    """An erode filter.<br>Each pixel gets the value of the min value of its neighbors"""
+    def __init__(self, **parameters):
+        super().__init__('Erode', **parameters)
+
+class Expression(KoronaModule):
+    """Module for generating combination echograms by an expression"""
+    def __init__(self, **parameters):
+        super().__init__('Expression', **parameters)
+
+class FillMissingData(KoronaModule):
+    """Creates missing pingdata"""
+    def __init__(self, **parameters):
+        super().__init__('FillMissingData', **parameters)
+
+class Filter3X3(KoronaModule):
+    """Class implementing a 3�3 filter"""
+    def __init__(self, **parameters):
+        super().__init__('Filter3X3', **parameters)
+
+class FiskViewDisplay(KoronaModule):
+    """Display module"""
+    def __init__(self, **parameters):
+        super().__init__('FiskViewDisplay', **parameters)
+
+class GroupEnd(KoronaModule):
+    """End of a module group"""
+    def __init__(self, **parameters):
+        super().__init__('GroupEnd', **parameters)
+
+class HorizontalOffsetCorrection(KoronaModule):
+    """Performs horizontal offset correction"""
+    def __init__(self, **parameters):
+        super().__init__('HorizontalOffsetCorrection', **parameters)
+
+class Isolation(KoronaModule):
+    """Isolates one category by zeroing out all pixels of different categories"""
+    def __init__(self, **parameters):
+        super().__init__('Isolation', **parameters)
+
+class Median(KoronaModule):
+    """Sets the pixel value to median of its 8 neighbors and itself"""
+    def __init__(self, **parameters):
+        super().__init__('Median', **parameters)
+
+class NoiseAcceptance(KoronaModule):
+    """Median noise acceptance"""
+    def __init__(self, **parameters):
+        super().__init__('NoiseAcceptance', **parameters)
+
+class NoiseMedianQuantification(KoronaModule):
+    """Median noise quantification"""
+    def __init__(self, **parameters):
+        super().__init__('NoiseMedianQuantification', **parameters)
+
+class NoiseQuantification(KoronaModule):
+    """Produces noise quantification datagrams"""
+    def __init__(self, **parameters):
+        super().__init__('NoiseQuantification', **parameters)
+
+class NoiseRemover(KoronaModule):
+    """Removes noise based on parameters in noise quantification datagrams"""
+    def __init__(self, **parameters):
+        super().__init__('NoiseRemover', **parameters)
+
+class NoiseVisualization(KoronaModule):
+    """Visualizes noise parameters in a separate window"""
+    def __init__(self, **parameters):
+        super().__init__('NoiseVisualization', **parameters)
+
+class PingCollapsing(KoronaModule):
+    """Collapses sequential pinging"""
+    def __init__(self, **parameters):
+        super().__init__('PingCollapsing', **parameters)
+
+class PingThinning(KoronaModule):
+    """Deletes pings"""
+    def __init__(self, **parameters):
+        super().__init__('PingThinning', **parameters)
+
+class PlanktonInversion(KoronaModule):
+    """Performs plankton inversion"""
+    def __init__(self, **parameters):
+        super().__init__('PlanktonInversion', **parameters)
+
+class Plugin(KoronaModule):
+    """Plugin (beta)"""
+    def __init__(self, **parameters):
+        super().__init__('Plugin', **parameters)
+
+class PulseCompressionFilter(KoronaModule):
+    """Applies pulse compression filter(s) to broadband data"""
+    def __init__(self, **parameters):
+        super().__init__('PulseCompressionFilter', **parameters)
+
+class RemoveBottom(KoronaModule):
+    """Removes bottom data"""
+    def __init__(self, **parameters):
+        super().__init__('RemoveBottom', **parameters)
+
+class Rescale(KoronaModule):
+    """Rescales some channels to fit into the logarithmic Sv range"""
+    def __init__(self, **parameters):
+        super().__init__('Rescale', **parameters)
+
+class SchoolCategorization(KoronaModule):
+    """Determines whether a school consists of one or more species, and categorizes the whole school<br>if the schools is a single species school"""
+    def __init__(self, **parameters):
+        super().__init__('SchoolCategorization', **parameters)
+
+class SchoolDetection(KoronaModule):
+    """Detects schools on a specified channel"""
+    def __init__(self, **parameters):
+        super().__init__('SchoolDetection', **parameters)
+
+class Smoother(KoronaModule):
+    """Performs smoothing by convolution"""
+    def __init__(self, **parameters):
+        super().__init__('Smoother', **parameters)
+
+class SpikeFilter(KoronaModule):
+    """Filters spikes"""
+    def __init__(self, **parameters):
+        super().__init__('SpikeFilter', **parameters)
+
+class SpotNoise(KoronaModule):
+    """Sets the pixel value to median of its 14 neighbors and itself provided original value is large compared to most neighbours"""
+    def __init__(self, **parameters):
+        super().__init__('SpotNoise', **parameters)
+
+class TemporaryComputationsBegin(KoronaModule):
+    """Start of temporary computations"""
+    def __init__(self, **parameters):
+        super().__init__('TemporaryComputationsBegin', **parameters)
+
+class TemporaryComputationsEnd(KoronaModule):
+    """End of temporary computations"""
+    def __init__(self, **parameters):
+        super().__init__('TemporaryComputationsEnd', **parameters)
+
+class ThresholdAllChannels(KoronaModule):
+    """Masks out values on all channels if some channels are too weak or too strong"""
+    def __init__(self, **parameters):
+        super().__init__('ThresholdAllChannels', **parameters)
+
+class Threshold(KoronaModule):
+    """Masks out values in specific range on individual channels"""
+    def __init__(self, **parameters):
+        super().__init__('Threshold', **parameters)
+
+class TimeInterval(KoronaModule):
+    """Module for processing only the pings in a specified time interval"""
+    def __init__(self, **parameters):
+        super().__init__('TimeInterval', **parameters)
+
+class Towfish(KoronaModule):
+    """Merges towfish data with main echosounder data"""
+    def __init__(self, **parameters):
+        super().__init__('Towfish', **parameters)
+
+class TrackFilter(KoronaModule):
+    """Filters rejected tracks"""
+    def __init__(self, **parameters):
+        super().__init__('TrackFilter', **parameters)
+
+class Tracking(KoronaModule):
+    """Tracks single targets"""
+    def __init__(self, **parameters):
+        super().__init__('Tracking', **parameters)
+
+class TsDetection(KoronaModule):
+    """Detects single targets"""
+    def __init__(self, **parameters):
+        super().__init__('TsDetection', **parameters)
+
+class VerticalOffsetCorrection(KoronaModule):
+    """Performs vertical offset correction"""
+    def __init__(self, **parameters):
+        super().__init__('VerticalOffsetCorrection', **parameters)
+
+class Writer(KoronaModule):
+    """Writes to a .raw file"""
+    def __init__(self, **parameters):
+        super().__init__('Writer', **parameters)
+
+class NetcdfWriter(KoronaModule):
+    """Writes to a .nc file"""
+    def __init__(self, **parameters):
+        super().__init__('NetcdfWriter', **parameters)
+

koronascript-0.1/KoronaScript/__init__.py

@@ -0,0 +1,78 @@
+# Class to represent and run a sequence of Korona moduleapplications
+# Example usage:
+#    ks = KoronaScript(global parameters)
+#    ks.add(KoronaModule(parametres)
+#    ks.add...
+#    ks.write(path)
+#    ks.run()
+
+import subprocess
+import tempfile
+import os
+import sys
+import json
+
+from .KoronaModule import KoronaModule, global_spec
+
+class KoronaScript():
+    '''Construct, store, and run a set of Korona modules'''
+
+    def __init__(self, **parameters): # global parameters
+        self._module_list = []
+        self._config = global_spec
+        for k in parameters:
+            if k not in global_spec:
+                print(f'Unknown global parameter "{k}" - aborting')
+                exit(-1)
+            self._config[k] = parameters[k]
+
+    def add(self, module):
+        '''Add a module to the script'''
+        self._module_list.append(module)
+        return self
+
+    def write(self, cfs=sys.stdout, cds=sys.stdout, cdsname=None):
+        '''Write the cds and cfs files'''
+        cfs.write('<?xml version="1.0" encoding="UTF-8"?>\n\n')
+        cfs.write('<ConfigFiles context="Korona">\n')
+        cfs.write(f'    <parameter name="ModuleConfiguration" ref="CfsDirectory">{cdsname}</parameter>\n')
+        for k,v in self._config.items():
+            if v is None:
+                cfs.write(f'    <parameter name="{k}"/>\n')
+            else:
+                cfs.write(f'    <parameter name="{k}">{v}</parameter>\n')
+        cfs.write('</ConfigFiles>\n')
+
+        cds.write('<?xml version="1.0" encoding="UTF-8"?>\n\n')
+        cds.write('<ModuleContainer version="3">\n')
+        cds.write('  <modules>\n')
+        for m in self._module_list:
+            cds.write(m.to_xml())
+        cds.write('  </modules>\n')
+        cds.write('</ModuleContainer>\n')
+
+    def run(self, src, dst):
+        '''Save the files (to /tmp?) and call Korona to execute them'''
+        cfs, cfsname = tempfile.mkstemp(suffix='.cfs')
+        cds, cdsname = tempfile.mkstemp(suffix='.cds')
+        with os.fdopen(cds, 'w') as cdsfd:
+            with os.fdopen(cfs, 'w') as cfsfd:
+                self.write(cfs=cfsfd, cds=cdsfd, cdsname=cdsname)
+
+        # if os.getenv('JAVA_HOME'): (...)
+        lsss = os.getenv('LSSS')
+        if lsss is None:
+            print('LSSS environment variable not specified')
+            exit(-1)
+        os.environ['TOP_INSTALLATION_DIR'] = lsss
+
+        java = lsss+'/jre/bin/java'
+
+        # "-Xmx${MAX_MEMORY_MB}m" -classpath "$TOP_INSTALLATION_DIR/lib/jar/*" "-Djava.library.path=$JAVA_LIBRARY_PATH" "-Djna.library.path=$JAVA_LIBRARY_PATH" -XX:-UseGCOverheadLimit -XX:-OmitStackTraceInFastThrow -Dno.marec.incubator=true no.imr.korona.main.KoronaCliMain "$@"
+        javaopts = ['-classpath', f'{lsss}/lib/jar/*', '-Dno.marec.incubator=true', 'no.imr.korona.main.KoronaCliMain']
+        res = subprocess.run([java] + javaopts + ['batch', '--cfs', cfsname, '--source', src, '--destination', dst])
+        print(res.stdout)
+        if res.returncode != 0:
+            print(f'Warning: Java subprocess returned error code {res.returncode}')
+            print('Errors:')
+            print(res.stderr)

koronascript-0.1/MANIFEST.in

@@ -0,0 +1 @@
+include configuration/korona-info.json

koronascript-0.1/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: koronascript
+Version: 0.1
+Summary: Wrapper around Korona modules for processing echosounder data
+Home-page: https://github.com/CRIMAC-WP4-Machine-learning/CRIMAC-KoronaScript
+Author: Ketil Malde
+Author-email: ketil@malde.org
+Description-Content-Type: text/markdown
+
+# Running Korona through Python
+
+## Prerequisites
+
+### Install LSSS/Korona.
+
+This version of the KoronaScript is tested against lsss-2.16.0-alpha
+version. LSSS and korona is usually placed at
+`~/lsss/lsss-2.16.0-alpha` or a similar directory.
+
+Download the appropriate version from here:
+
+https://marec.no/tmp/lsss-2.16.0-alpha-20230922-1417-linux.zip
+
+https://marec.no/tmp/lsss-2.16.0-alpha-20230922-1417-windows.zip
+
+If you run linux you need to install the netcdf library separately:
+
+`apt-get install libnetcdf`
+
+### Add license 
+
+You need an LSSS licence. The licence have to be added according to the LSSS manual. the licence files are typically placed at the `~/marec/license` directory.
+
+### Set system variables
+
+This can be set at run time either by setting the LSSS environment
+variable in the shell
+~~~
+export LSSS=~/lsss-2.16.0-alpha/korona
+~~~
+before running your script, or by adding to path 
+~~~
+lsss = '~/lsss-2.16.0-alpha/korona'
+os.environ["LSSS"] = lsss
+~~~
+pointing at the LSSS environment to your script.
+
+# Usage
+
+Import the modules:
+
+	import KoronaScript as ks
+	import KoronaScript.Modules as ksm
+
+Create a script object:
+
+	ks = ks.KoronaScript(Categorization='categorization.xml',
+                     HorizontalTransducerOffsets='HorizontalTransducerOffsets.xml')
+
+Add some modules:
+
+	ks.add(ksm.EmptyPingRemoval())
+	ks.add(ksm.Comment(LineBreak='false', Label='CW_0256ms'))
+	ks.add(ksm.ChannelRemoval(Channels=[1,5,9,13,17],KeepSpecified='true'))
+	ks.add(ksm.Writer(RelativeDirectory='CW_0256ms'))
+
+Write out the resulting configuration:
+
+	ks.write()
+	
+Run the script:
+
+	ks.run(src="input_dir", dst="output_dir")
+
+The list of modules and their parameters can be found in the
+[configuration/korona-info.json](configuration/korona-info.json) file. 

koronascript-0.1/README.md

@@ -0,0 +1,67 @@
+# Running Korona through Python
+
+## Prerequisites
+
+### Install LSSS/Korona.
+
+This version of the KoronaScript is tested against lsss-2.16.0-alpha
+version. LSSS and korona is usually placed at
+`~/lsss/lsss-2.16.0-alpha` or a similar directory.
+
+Download the appropriate version from here:
+
+https://marec.no/tmp/lsss-2.16.0-alpha-20230922-1417-linux.zip
+
+https://marec.no/tmp/lsss-2.16.0-alpha-20230922-1417-windows.zip
+
+If you run linux you need to install the netcdf library separately:
+
+`apt-get install libnetcdf`
+
+### Add license 
+
+You need an LSSS licence. The licence have to be added according to the LSSS manual. the licence files are typically placed at the `~/marec/license` directory.
+
+### Set system variables
+
+This can be set at run time either by setting the LSSS environment
+variable in the shell
+~~~
+export LSSS=~/lsss-2.16.0-alpha/korona
+~~~
+before running your script, or by adding to path 
+~~~
+lsss = '~/lsss-2.16.0-alpha/korona'
+os.environ["LSSS"] = lsss
+~~~
+pointing at the LSSS environment to your script.
+
+# Usage
+
+Import the modules:
+
+	import KoronaScript as ks
+	import KoronaScript.Modules as ksm
+
+Create a script object:
+
+	ks = ks.KoronaScript(Categorization='categorization.xml',
+                     HorizontalTransducerOffsets='HorizontalTransducerOffsets.xml')
+
+Add some modules:
+
+	ks.add(ksm.EmptyPingRemoval())
+	ks.add(ksm.Comment(LineBreak='false', Label='CW_0256ms'))
+	ks.add(ksm.ChannelRemoval(Channels=[1,5,9,13,17],KeepSpecified='true'))
+	ks.add(ksm.Writer(RelativeDirectory='CW_0256ms'))
+
+Write out the resulting configuration:
+
+	ks.write()
+	
+Run the script:
+
+	ks.run(src="input_dir", dst="output_dir")
+
+The list of modules and their parameters can be found in the
+[configuration/korona-info.json](configuration/korona-info.json) file.