ImageDev

- Getting Started
- ImageDev Python
- ImageDev C#
- ImageDev C++
- Licensing Information
- Redistributable Files
- Processing
- Image Manipulation
- - Synthetic Images
  - - RandomImage2d
    - RandomImage3d
    - RandomGaussianImage2d
    - RandomGaussianImage3d
    - RadialFunctionImage2d
    - RadialFunctionImage3d
    - OrientedLinesImage2d
    - OrientedLinesImage3d
    - RandomSphereImage3d
    - BoxGridImage2d
    - BoxGridImage3d
    - WedgeMaskImage3d
    - PointSpreadFunctionImage3d
  - Image Editing
  - - ConvertImage
    - ResetImage
    - CopyImage
    - PasteImage2d
    - PasteImage3d
    - CropImage2d
    - CropImage3d
    - SampleImage2d
    - SampleImage3d
    - InterlaceFrames2d
    - DeinterlaceFrames2d
  - Stack Operations
  - - SequenceConcatenation
    - SequenceToMultispectral
    - SequenceToVolume
    - VolumeToSequence
    - MultispectralToSequence
    - GetSliceFromVolume3d
    - SetSliceToVolume3d
    - GetObliqueSliceFromVolume3d
    - ImageStackProjection3d
    - VolumeProjection3d
- Geometry And Matching
- - Geometric Transforms
  - - Shearing3d
    - TranslateImage2d
    - TranslateImage3d
    - Flip2d
    - Flip3d
    - FlipImage2d
    - FlipImage3d
    - TransposeImage2d
    - TransposeImage3d
    - SwapQuadrants
    - Rotate2d
    - Rotate3d
    - RotationGenerator3d
    - Resize2d
    - Resize3d
    - RescaleByFactor
    - RescaleImageByFactor
    - ResampleAffine2d
    - ResampleAffine3d
    - ResampleElastic2d
    - SurfaceUnfolding3d
  - Pattern Recognition
  - - BinaryCorrelation2d
    - CrossCorrelation2d
    - CorrelationByDifference2d
    - CorrelationBySignChange2d
  - Registration
  - - ImagePrealignment3d
    - AffineRegistration
    - ElasticRegistration2d
- Arithmetic And Logic
- - Arithmetical Operations
  - - AbsoluteValue
    - AbsoluteMaximumWithImage
    - ArithmeticOperationWithImage
    - ArithmeticOperationWithValue
    - BlendWithImage
    - BlendWithValue
    - DirectionalBlending2d
    - CombineByMask
    - ImageFormula
    - EigenDecomposition2d
    - EigenDecomposition3d
  - Logical Operations
  - - MaskImage
    - LogicalOperationWithImage
    - LogicalOperationWithValue
    - LogicalNot
    - InvertImage
    - BitShift
- Image Filtering
- - Grayscale Transforms
  - - RescaleIntensity
    - StackRescaleIntensity
    - MatchContrast
    - HistogramEqualization
    - Clahe2d
    - Clahe3d
    - AdaptiveHistogramEqualization
    - ApplyGrayscaleLut
    - BackgroundImage2d
    - RadialBackgroundImage2d
    - ShadingCorrection
    - Exponential
    - Logarithm
    - Square
    - SquareRoot
    - RingArtifactRemoval3d
    - BeamHardeningCorrection3d
  - Color Transforms
  - - ColorToLightness
    - GetColorChannel
    - ColorToGrayscale
    - GrayscaleToColor
    - ColorSpaceConversion
    - ColorAntialiasing2d
    - BayerToRgb2d
    - DecorrelationStretch2d
    - BlendAlphaChannelWithImage
    - BlendAlphaChannelWithValue
  - Smoothing And Denoising
  - - BoxFilter2d
    - BoxFilter3d
    - MedianFilter2d
    - MedianFilter3d
    - GaussianFilter2d
    - GaussianFilter3d
    - ExponentialFilter2d
    - RecursiveExponentialFilter2d
    - RecursiveExponentialFilter3d
    - NonLocalMeansFilter2d
    - NonLocalMeansFilter3d
    - CurvatureDrivenDiffusion
    - BilateralFilter2d
    - BilateralFilter3d
    - MajorityFilter2d
    - MajorityFilter3d
    - SigmaFilter2d
    - SigmaFilter3d
    - Despeckle2d
    - Despeckle3d
    - NagaoFilter2d
    - NagaoFilter3d
    - SnnFilter2d
    - SnnFilter3d
    - FlowInpainting
  - Sharpening
  - - Deblurring2d
    - Delineate2d
    - Delineate3d
    - UnsharpMasking2d
    - UnsharpMasking3d
    - Shade2d
    - RichardsonLucyDeconvolution
  - Texture Filters
  - - MeanFilter2d
    - MeanFilter3d
    - VarianceFilter2d
    - VarianceFilter3d
    - SkewnessFilter2d
    - SkewnessFilter3d
    - KurtosisFilter2d
    - KurtosisFilter3d
    - ContrastFilter2d
    - ContrastFilter3d
    - VariationFilter2d
    - VariationFilter3d
    - EnergyFilter2d
    - EnergyFilter3d
    - EntropyFilter2d
    - EntropyFilter3d
    - AutocorrelationFilter
    - LocalAutocorrelationFilter2d
    - ImageCurvature2d
    - ImageCurvature3d
    - StructureEnhancementFilter2d
    - StructureEnhancementFilter3d
    - ScaleSpaceLogFilter2d
    - ScaleSpaceLogFilter3d
  - Frequency Domain
  - - ComplexFft
    - ComplexFftInverse
    - ComplexCenteredFft
    - ComplexCenteredFftInverse
    - CartesianToPolar2d
    - PolarToCartesian2d
    - ConvolutionWithImage
    - ConvolutionWithImage2d
    - RadialFrequencyFilter2d
    - GaborFiltering2d
- Edge Detection
- - Gradient
  - - GradientOperator2d
    - GradientOperator3d
    - VectorToMagnitude2d
    - VectorToMagnitude3d
    - GradientVector2d
    - GradientVector3d
    - GradientMagnitude2d
    - GradientMagnitude3d
    - MorphologicalGradient2d
    - MorphologicalGradient3d
    - RadialGradientCentered2d
    - RadialGradientCentered3d
    - RadialGradientContour2d
    - RadialGradientContour3d
    - RadialGradientLabel2d
    - RadialGradientLabel3d
  - Laplacian
  - - DobFilter2d
    - DobFilter3d
    - MorphologicalLaplacian
    - RecursiveLaplacian2d
    - RecursiveLaplacian3d
  - Other Derivatives
  - - GaussianDerivative2d
    - GaussianDerivative3d
    - GaussianHessianMatrix2d
    - GaussianHessianMatrix3d
    - GaussianGradientTensor2d
    - GaussianGradientTensor3d
  - Edge Marking
  - - ImageLocalMaxima2d
    - ImageLocalMaxima3d
    - RidgeDetection
    - ZeroCrossings2d
    - DijkstraShortestPath2d
    - EigenvaluesToStructureness2d
    - EigenvaluesToStructureness3d
    - TensorVoting2d
    - CannyEdgeDetector2d
    - CannyEdgeDetector3d
- Image Segmentation
- - Binarization
  - - Thresholding
    - ThresholdingByCriterion
    - AutoThresholdingBright
    - AutoThresholdingDark
    - ColorThresholding
    - TopHat
    - FeatureAdaptiveThresholding
    - AdaptiveThresholding2d
    - AdaptiveThresholding3d
    - HysteresisThresholding
  - Labeling
  - - Labeling2d
    - Labeling3d
    - ReorderLabels
    - AssignLabel
    - AddObjectToLabel
    - GroupCloseLabelsl2d
  - Feature Selection
  - - KillBorder2d
    - KillBorder3d
    - RemoveSmallSpots
    - ObjectBoundaries
    - BinarySmoothing2d
    - BinarySmoothing3d
    - LabelInterfaces
  - Separating And Filling
  - - FillHoles2d
    - FillHoles3d
    - RemoveSmallHoles
    - FillImageBorder3d
    - ExpandLabelBoundaries
    - SeparateObjects
    - HExtremaWatershed
    - SeparateObjectsByBlock
    - HExtremaWatershedByBlock
    - ConvexHull2d
  - Region Growing
  - - MarkerBasedWatershed2d
    - MarkerBasedWatershed3d
    - MarkerBasedWatershedByBlock
    - MarkerBasedWatershedBasinsByBlock
    - ExpandLabelsOnBackground
    - FloodFillThreshold2d
    - FloodFillThreshold3d
    - Waterpixel
  - Computational Geometry
  - - PolylineResampler2d
    - PolylineResampler3d
    - PolylineExtrusion3d
    - SurfaceFitting3d
- Mathematical Morphology
- - Erosion And Dilation
  - - Erosion2d
    - Erosion3d
    - Dilation2d
    - Dilation3d
    - ErosionDisk2d
    - ErosionDisk3d
    - ErosionBall3d
    - DilationDisk2d
    - DilationDisk3d
    - DilationBall3d
    - ErosionLine2d
    - ErosionLine3d
    - DilationLine2d
    - DilationLine3d
    - ErosionColor2d
    - DilationColor2d
    - SelectiveErosion2d
    - SelectiveErosion3d
    - SelectiveDilation2d
    - SelectiveDilation3d
  - Opening And Closing
  - - Opening2d
    - Opening3d
    - Closing2d
    - Closing3d
    - OpeningDisk2d
    - OpeningDisk3d
    - OpeningBall3d
    - ClosingDisk2d
    - ClosingDisk3d
    - ClosingBall3d
    - OpeningLine2d
    - OpeningLine3d
    - ClosingLine2d
    - ClosingLine3d
    - OpeningLineMaximum
    - ClosingLineMinimum
    - OpeningColor2d
    - ClosingColor2d
    - OpeningByReconstruction2d
    - OpeningByReconstruction3d
    - ClosingByReconstruction2d
    - ClosingByReconstruction3d
    - OpeningDiskByReconstruction2d
    - OpeningBallByReconstruction3d
    - ClosingDiskByReconstruction2d
    - ClosingBallByReconstruction3d
    - SelectiveOpening2d
    - SelectiveOpening3d
    - SelectiveClosing2d
    - SelectiveClosing3d
  - Hit Or Miss And Skeleton
  - - Skeleton
    - Centerline3d
    - InfluenceZones
    - Centroid2d
    - EndPoints2d
    - EndPoints3d
    - Pruning2d
    - Pruning3d
    - IsolatedPoints2d
    - IsolatedPoints3d
    - TriplePoints2d
    - InteriorPoints2d
    - ApplyMorphologicalLut2d
    - ApplyMorphologicalLut3d
  - Geodesic Transformations
  - - ReconstructionFromMarkers2d
    - ReconstructionFromMarkers3d
    - GrayscaleReconstruction2d
    - GrayscaleReconstruction3d
    - GrayscaleFillHoles2d
    - GrayscaleFillHoles3d
    - HExtrema2d
    - HExtrema3d
    - RegionalExtrema2d
    - RegionalExtrema3d
    - UltimateErosion
  - Distance Maps
  - - DistanceMap2d
    - DistanceMap3d
    - EuclideanDistanceMap3d
    - EuclideanDistanceMap2d
    - GeodesicDistanceMap
    - ClosestBoundaryPoints2d
    - ClosestBoundaryPoints3d
    - TimeMap
    - LocalThicknessMap3d
    - GeodesicPropagation2d
    - GeodesicMaxima
    - GeodesicMinima
- Image Analysis
- - Image Measurements
  - - BinaryAnalysis
    - Area2d
    - Area3d
    - IntensityIntegral2d
    - IntensityIntegral3d
    - ObjectCount
    - DistanceMean2d
    - EulerNumber2d
    - EulerNumber3d
    - FractalDimension
    - CurvatureIntegrals3d
  - Image Statistics
  - - IntensityExtrema
    - IntensityStatistics
    - IntensityMaskedStatistics
    - IntensityHistogram
    - IntensityBinHistogram
    - AutoThresholdingValue
    - CompareImage
    - CompareValue
    - SimilarityMetricValue
    - SsimValue2d
    - SsimValue3d
    - RegionSimilarity
    - RadialIntensityProfile2d
    - RadialIntensityProfile3d
    - CylindricalIntensityProfile3d
    - RadialAutocorrelationProfile
    - Cooccurrence2d
    - MeasureGaussianNoise
    - LocalMaxima2d
    - LocalMaxima3d
    - PeakExtractor
    - LocalDensityMap2d
    - LocalDensityMap3d
    - SegmentationMetrics
  - Individual Measurements
  - - VolumeFractionByLabel
    - LabelCountByRegion
    - VolumeFractionByRegion
    - LabelAnalysis
    - LabelFiltering
    - LabelFilteringAnalysis
    - FilterAnalysis
    - MeasurementToImage
    - FilterByMeasurement
    - SieveLabeling
  - Moments And Orientations
  - - MomentsOfInertia2d
    - MomentsOfInertia3d
    - InertiaMoment2d
    - Eccentricity2d
    - OrientationMapFourier3d
    - OrientationMatchingFourier3d
  - Morphometry
  - - ObjectVolume
    - TotalImageVolume
    - ObjectBoundaryArea
    - TotalImageBoundaryArea
    - AverageObjectAreaPerSlice3d
    - AverageObjectCountPerSlice3d
    - ObjectImageRatio
    - ObjectSpecificSurface
    - ObjectSurfaceDensity
    - PorosityPercentage3d
    - FragmentationIndex
    - StructureModelIndex3d
    - AverageObjectThickness3d
    - AverageSpaceThickness3d
    - ObjectLinearDensity3d
    - DegreeOfAnisotropy
  - Propagation
  - - AxisPropagationBinary3d
    - AxisPropagationBinaryWithSeeds3d
    - AxisPropagationLabel3d
    - AxisPropagationLabelWithSeeds3d
    - AxisPropagationDistance3d
    - EstimateShortestPath3d
    - PercolationThreshold3d
    - AxisConnectivity3d
    - CentroidPathTortuosity3d
- Machine Learning
- - Classification
  - - AutoSegmentation3Phases
    - AutoIntensityClassification
    - SupervisedTextureClassification2d
    - SupervisedTextureClassification3d
    - TextureClassificationCreate
    - TextureClassificationTrain
    - TextureClassificationApply
  - Deep learning
  - - OnnxPredictionFiltering2d
    - OnnxPredictionFiltering3d
    - OnnxPredictionSegmentation2d
    - OnnxPredictionSegmentation3d
    - OnnxPredictionTwoOutputs2d
    - OnnxPredictionTwoOutputs3d
- Business Application
- - Dental
  - - DentalWallSegmentation3d
    - DentalMeshExtraction3d
    - DentalUnfolding3d
- IO
- - Image Data
  - - ReadVipImage
    - WriteVipImage
  - Algebraic Data
  - - ReadArrayXd
    - ReadArrayXi64
    - WriteArrayXd
    - WriteArrayXi64
  - Model
  - - ReadOnnxModel
- CUDA
- - Geometry And Matching
  - - CudaCrossCorrelation2d
    - CudaTemplateMatching3d
  - Image Filtering
  - - CudaBoxFilter2d
    - CudaMedianFilter2d
    - CudaGaussianFilter3d
    - CudaAdaptiveManifoldNlmFilter
  - Mathematical Morphology
  - - CudaErosion2d
    - CudaDilation2d
    - CudaOpening2d
    - CudaClosing2d
- Utilities
- Initialization
- Processing
- Syntax Check
- Visualization
- Data Object
- Image Data
- Kernels
- - MorphologicalKernel2d
  - MorphologicalKernel3d
  - MorphologicalLut2d
  - MorphologicalLut3d
- Model
- - TextureClassificationModel
  - OnnxModel
- Global Measurements
- - Image Measurements
  - - Area2dMsr
    - Area3dMsr
    - IntensityIntegral2dMsr
    - IntensityIntegral3dMsr
    - ObjectCountMsr
    - DistanceMeanMsr
    - Euler2dMsr
    - Euler3dMsr
    - FractalMsr
    - CurvatureIntegralsMsr
  - Image Statistics
  - - IntensityExtremaMsr
    - StatisticsMsr
    - IntensityHistogramMsr
    - IntensityBinHistogramMsr
    - CompareMsr
    - SimilarityMetricValueMsr
    - SsimValueMsr
    - RegionSimilarityMsr
    - SegmentationMetricsObjectMsr
    - SegmentationMetricsImageMsr
    - CylindricalIntensityProfileMsr
    - RadialIntensityProfileMsr
    - CorrelationMsr
    - CoocurrrenceMsr
    - GaussianNoiseMsr
    - LocalMaximaMsr
    - PeakExtractorMsr
  - Individual Measurements
  - - VolumeFractionByLabelMsr
    - LabelCountByRegionMsr
    - VolumeFractionByRegionMsr
  - Moments And Orientations
  - - MomentsOfInertia2dMsr
    - MomentsOfInertia3dMsr
    - MeanInertiaMomentMsr
    - Eccentricity2dMsr
    - LocalOrientation3dMsr
  - Morphometry
  - - ObjectVolumeMsr
    - ImageVolumeMsr
    - ObjectBoundaryAreaMsr
    - ImageBoundaryAreaMsr
    - AverageObjectAreaPerSliceMsr
    - AverageObjectCountPerSliceMsr
    - ObjectImageRatioMsr
    - ObjectSpecificSurfaceMsr
    - ObjectSurfaceDensityMsr
    - PorosityPercentageMsr
    - FragmentationMsr
    - StructureModelIndexMsr
    - AverageObjectThicknessMsr
    - AverageSpaceThicknessMsr
    - ObjectLinearDensityMsr
    - AnisotropyDegreeMsr
  - Propagation
  - - AxisPropagationBinary3dMsr
    - AxisPropagationLabel3dMsr
    - AxisPropagationDistance3dMsr
    - PercolationThreshold3dMsr
    - CentroidTortuosity3dMsr
  - Geometry And Matching
  - - CrossCorrelation2dMsr
  - Edge Detection
  - - CannyEdgeDetectorMsr
  - Image Segmentation
  - - AutoThresholdingMsr
    - AutoSegmentation3PhasesMsr
  - Mathematical Morphology
  - - ApplyMorphologicalLutMsr
- Analysis Measurements
- - AnalysisMsr
  - Measurement
  - Native Measurements
  - - Geometry
    - Feret
    - Intensity
    - Histogram
    - Inertia
    - Locate
    - Segment
    - Cooccurrence
  - CustomMeasurement
  - MeasurementAttributes
  - - Quantile
    - Histogram
    - Feret2d
    - Feret3d
    - NeighborCount
    - Cooccurrence
    - Breadth3d
  - MeasurementGroup
- Measurement Information
- - FieldInformation
  - CustomMeasurementInfo
- CUDA
- - CudaContext
- User Guide
- First Steps
- - Hello ImageDev
  - Initialize ImageDev
- Image Management
- - Create 2D Image
  - Create 3D Image
  - Data Transfer
- Standard Processing
- - Denoising
  - Thresholding
- Image Analysis
- - Global Analysis
  - Label Analysis
  - Measurement Browsing
  - Measurement Group
  - Custom Analysis
- Advanced Processing
- - Algorithm Tracking
- Typical Use Cases
- - Particle Analysis
  - Pore Analysis

# ScaleSpaceLogFilter2d

This filter applies a Laplacian of Gaussian (LoG) filter at different scales, to enhance circular or elliptical (blob-like) objects.
Access to parameter description
This filter enhances objects that appear bright on a dark background. For each pixel, the maximum LoG response and the scale providing this maximum response are recorded, and presented as two output images. Each LoG filter is normalized for scale-invariance.
The scales are defined by a minimum and maximum standard deviation of the gaussian kernel, and a number of scales. Minimum and maximum standard deviations can be either isotropic, or different for each axis. The corresponding standard deviation for each scale and axis is provided in an output data frame, the scale table. When enabled, the output scale image indicates for each pixel the index of the scale table corresponding to the selected scale.
Reference:
S.V. Fotin, D.F. Yankelevitz, C.I. Henschke, and A.P. Reeves, A multiscale Laplacian of Gaussian (LoG) filtering approach to pulmonary nodule detection from whole-lung CT scans . Proceedings of the SPIE , vol.7260, id.72601Q, Medical Imaging 2009: Computer-Aided Diagnosis, Mar 2009.
See also

- GaussianDerivative2d
- StructureEnhancementFilter2d
- ScaleSpaceLogFilter3d

##
Function Syntax

This function returns a ScaleSpaceLogFilter2dOutput structure containing outputImage, scaleTable and outputScaleImage.

    // Output structure of the scaleSpaceLogFilter2d function.
    struct ScaleSpaceLogFilter2dOutput
    {
        /// The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer.
        std::shared_ptr< iolink::ImageView > outputScaleImage;
        /// The output table contains all couples of standard deviation values for X and Y axes used to compute each scale.
        std::shared_ptr< iolink::DataFrameView > scaleTable;
    };

    // Function prototype
    ScaleSpaceLogFilter2dOutput
    scaleSpaceLogFilter2d( std::shared_ptr< iolink::ImageView > inputImage,
                           const iolink::Vector2d& minimumStandardDeviation,
                           const iolink::Vector2d& maximumStandardDeviation,
                           uint32_t numberOfScales,
                           ScaleSpaceLogFilter2d::Lightness lightness,
                           bool selectIndexImage,
                           std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                           std::shared_ptr< iolink::DataFrameView > scaleTable = nullptr,
                           std::shared_ptr< iolink::ImageView > outputScaleImage = nullptr );

This function returns a tuple containing output_image, scale_table and output_scale_image.

    // Function prototype.
    scale_space_log_filter_2d(input_image: idt.ImageType,
                              minimum_standard_deviation: Union[Iterable[int], Iterable[float]] = [1, 1],
                              maximum_standard_deviation: Union[Iterable[int], Iterable[float]] = [1, 1],
                              number_of_scales: int = 1,
                              lightness: ScaleSpaceLogFilter2d.Lightness = ScaleSpaceLogFilter2d.Lightness.BRIGHT,
                              select_index_image: bool = False,
                              output_image: idt.ImageType = None,
                              scale_table: Union[iolink.DataFrameView, None] = None,
                              output_scale_image: idt.ImageType = None) -> Tuple[idt.ImageType, Union[iolink.DataFrameView, None], idt.ImageType]

This function returns a ScaleSpaceLogFilter2dOutput structure containing outputImage, scaleTable and outputScaleImage.

    /// Output structure of the ScaleSpaceLogFilter2d function.
    public struct ScaleSpaceLogFilter2dOutput
    {
        ///
        /// The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float.
        ///
        public IOLink.ImageView outputImage;
        ///
        /// The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer.
        ///
        public IOLink.ImageView outputScaleImage;
        ///
        /// The output table contains all couples of standard deviation values for X and Y axes used to compute each scale.
        ///
        public IOLink.DataFrameView scaleTable;
    };

    // Function prototype.
    public static ScaleSpaceLogFilter2dOutput
    ScaleSpaceLogFilter2d( IOLink.ImageView inputImage,
                           double[] minimumStandardDeviation = null,
                           double[] maximumStandardDeviation = null,
                           UInt32 numberOfScales = 1,
                           ScaleSpaceLogFilter2d.Lightness lightness = ImageDev.ScaleSpaceLogFilter2d.Lightness.BRIGHT,
                           bool selectIndexImage = false,
                           IOLink.ImageView outputImage = null,
                           IOLink.DataFrameView scaleTable = null,
                           IOLink.ImageView outputScaleImage = null );

##
Class Syntax

    // Command constructor.
    ScaleSpaceLogFilter2d();

    /// Gets the inputImage parameter.
    /// The input grayscale image. The image type can be integer or floating point.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input grayscale image. The image type can be integer or floating point.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the minimumStandardDeviation parameter.
    /// The Minimum standard deviation for X and Y axes, in pixels.
    iolink::Vector2d minimumStandardDeviation() const;
    /// Sets the minimumStandardDeviation parameter.
    /// The Minimum standard deviation for X and Y axes, in pixels.
    void setMinimumStandardDeviation( const iolink::Vector2d& minimumStandardDeviation );

    /// Gets the maximumStandardDeviation parameter.
    /// The Maximum standard deviation for X and Y axes, in pixels.
    iolink::Vector2d maximumStandardDeviation() const;
    /// Sets the maximumStandardDeviation parameter.
    /// The Maximum standard deviation for X and Y axes, in pixels.
    void setMaximumStandardDeviation( const iolink::Vector2d& maximumStandardDeviation );

    /// Gets the numberOfScales parameter.
    /// The number of scales used for computing Laplacian of Gaussian filters.
    uint32_t numberOfScales() const;
    /// Sets the numberOfScales parameter.
    /// The number of scales used for computing Laplacian of Gaussian filters.
    void setNumberOfScales( const uint32_t& numberOfScales );

    /// Gets the lightness parameter.
    /// The lightness type of object to detect.
    ScaleSpaceLogFilter2d::Lightness lightness() const;
    /// Sets the lightness parameter.
    /// The lightness type of object to detect.
    void setLightness( const ScaleSpaceLogFilter2d::Lightness& lightness );

    /// Gets the selectIndexImage parameter.
    /// The index image is generated only if set to true.
    bool selectIndexImage() const;
    /// Sets the selectIndexImage parameter.
    /// The index image is generated only if set to true.
    void setSelectIndexImage( const bool& selectIndexImage );

    /// Gets the outputImage parameter.
    /// The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the scaleTable parameter.
    /// The output table contains all couples of standard deviation values for X and Y axes used to compute each scale.
    std::shared_ptr< iolink::DataFrameView > scaleTable() const;
    /// Sets the scaleTable parameter.
    /// The output table contains all couples of standard deviation values for X and Y axes used to compute each scale.
    void setScaleTable( const std::shared_ptr< iolink::DataFrameView >& scaleTable );

    /// Gets the outputScaleImage parameter.
    /// The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer.
    std::shared_ptr< iolink::ImageView > outputScaleImage() const;
    /// Sets the outputScaleImage parameter.
    /// The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer.
    void setOutputScaleImage( std::shared_ptr< iolink::ImageView > outputScaleImage );

    // Method to launch the command.
    void execute();

    # Property of the inputImage parameter.
    ScaleSpaceLogFilter2d.input_image
    # Property of the minimumStandardDeviation parameter.
    ScaleSpaceLogFilter2d.minimum_standard_deviation
    # Property of the maximumStandardDeviation parameter.
    ScaleSpaceLogFilter2d.maximum_standard_deviation
    # Property of the numberOfScales parameter.
    ScaleSpaceLogFilter2d.number_of_scales
    # Property of the lightness parameter.
    ScaleSpaceLogFilter2d.lightness
    # Property of the selectIndexImage parameter.
    ScaleSpaceLogFilter2d.select_index_image
    # Property of the outputImage parameter.
    ScaleSpaceLogFilter2d.output_image
    # Property of the scaleTable parameter.
    ScaleSpaceLogFilter2d.scale_table
    # Property of the outputScaleImage parameter.
    ScaleSpaceLogFilter2d.output_scale_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ScaleSpaceLogFilter2d()

    // Property of the inputImage parameter.
    ScaleSpaceLogFilter2d.inputImage
    // Property of the minimumStandardDeviation parameter.
    ScaleSpaceLogFilter2d.minimumStandardDeviation
    // Property of the maximumStandardDeviation parameter.
    ScaleSpaceLogFilter2d.maximumStandardDeviation
    // Property of the numberOfScales parameter.
    ScaleSpaceLogFilter2d.numberOfScales
    // Property of the lightness parameter.
    ScaleSpaceLogFilter2d.lightness
    // Property of the selectIndexImage parameter.
    ScaleSpaceLogFilter2d.selectIndexImage
    // Property of the outputImage parameter.
    ScaleSpaceLogFilter2d.outputImage
    // Property of the scaleTable parameter.
    ScaleSpaceLogFilter2d.scaleTable
    // Property of the outputScaleImage parameter.
    ScaleSpaceLogFilter2d.outputScaleImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image. The image type can be integer or floating point. | Image | Grayscale | nullptr
| minimumStandardDeviation | The Minimum standard deviation for X and Y axes, in pixels. | Vector2d | Any value | {1.f, 1.f}
| maximumStandardDeviation | The Maximum standard deviation for X and Y axes, in pixels. | Vector2d | Any value | {1.f, 1.f}
| numberOfScales | The number of scales used for computing Laplacian of Gaussian filters. | UInt32 | [1, 255] | 1
| lightness | The lightness type of object to detect.
BRIGHT | Bright objects are extracted from a dark background.
DARK | Dark objects are extracted from a bright background.
| Enumeration |  | BRIGHT
| selectIndexImage | The index image is generated only if set to true. | Bool |  | false
| outputImage | The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float. | Image |  | nullptr
| scaleTable | The output table contains all couples of standard deviation values for X and Y axes used to compute each scale. | DataFrameView |  | nullptr
| outputScaleImage | The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer. This image is not generated if the selectIndexImage parameter is set to False. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input grayscale image. The image type can be integer or floating point. | image | Grayscale | None
| minimum_standard_deviation | The Minimum standard deviation for X and Y axes, in pixels. | vector2d | Any value | [1, 1]
| maximum_standard_deviation | The Maximum standard deviation for X and Y axes, in pixels. | vector2d | Any value | [1, 1]
| number_of_scales | The number of scales used for computing Laplacian of Gaussian filters. | uint32 | [1, 255] | 1
| lightness | The lightness type of object to detect.
BRIGHT | Bright objects are extracted from a dark background.
DARK | Dark objects are extracted from a bright background.
| enumeration |  | BRIGHT
| select_index_image | The index image is generated only if set to true. | bool |  | False
| output_image | The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float. | image |  | None
| scale_table | The output table contains all couples of standard deviation values for X and Y axes used to compute each scale. | data_frame_view |  | None
| output_scale_image | The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer. This image is not generated if the selectIndexImage parameter is set to False. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image. The image type can be integer or floating point. | Image | Grayscale | null
| minimumStandardDeviation | The Minimum standard deviation for X and Y axes, in pixels. | Vector2d | Any value | {1f, 1f}
| maximumStandardDeviation | The Maximum standard deviation for X and Y axes, in pixels. | Vector2d | Any value | {1f, 1f}
| numberOfScales | The number of scales used for computing Laplacian of Gaussian filters. | UInt32 | [1, 255] | 1
| lightness | The lightness type of object to detect.
BRIGHT | Bright objects are extracted from a dark background.
DARK | Dark objects are extracted from a bright background.
| Enumeration |  | BRIGHT
| selectIndexImage | The index image is generated only if set to true. | Bool |  | false
| outputImage | The output image representing the maximum LoG response among all scale inputs. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to float. | Image |  | null
| scaleTable | The output table contains all couples of standard deviation values for X and Y axes used to compute each scale. | DataFrameView |  | null
| outputScaleImage | The output image from which each intensity represents the index of the selected scale. Its dimensions, calibration and interpretation are forced to the same values as the input image. Its type is forced to 8-bit unsigned integer. This image is not generated if the selectIndexImage parameter is set to False. | Image |  | null

## Object Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

    ScaleSpaceLogFilter2d scaleSpaceLogFilter2dAlgo;
    scaleSpaceLogFilter2dAlgo.setInputImage( polystyrene );
    scaleSpaceLogFilter2dAlgo.setMinimumStandardDeviation( {1.0, 1.0} );
    scaleSpaceLogFilter2dAlgo.setMaximumStandardDeviation( {3.0, 3.0} );
    scaleSpaceLogFilter2dAlgo.setNumberOfScales( 1 );
    scaleSpaceLogFilter2dAlgo.setLightness( ScaleSpaceLogFilter2d::Lightness::BRIGHT );
    scaleSpaceLogFilter2dAlgo.setSelectIndexImage( true );
    scaleSpaceLogFilter2dAlgo.execute();

    std::cout << "outputImage:" << scaleSpaceLogFilter2dAlgo.outputImage()->toString();
    std::cout << "scaleTable:" << scaleSpaceLogFilter2dAlgo.scaleTable()->shape();
    std::cout << "outputScaleImage:" << scaleSpaceLogFilter2dAlgo.outputScaleImage()->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    scale_space_log_filter_2d_algo = imagedev.ScaleSpaceLogFilter2d()
    scale_space_log_filter_2d_algo.input_image = polystyrene
    scale_space_log_filter_2d_algo.minimum_standard_deviation = [1.0, 1.0]
    scale_space_log_filter_2d_algo.maximum_standard_deviation = [3.0, 3.0]
    scale_space_log_filter_2d_algo.number_of_scales = 1
    scale_space_log_filter_2d_algo.lightness = imagedev.ScaleSpaceLogFilter2d.BRIGHT
    scale_space_log_filter_2d_algo.select_index_image = True
    scale_space_log_filter_2d_algo.execute()

    print("output_image:", str(scale_space_log_filter_2d_algo.output_image))
    print("scale_table:", str(scale_space_log_filter_2d_algo.scale_table))
    print("output_scale_image:", str(scale_space_log_filter_2d_algo.output_scale_image))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

    ScaleSpaceLogFilter2d scaleSpaceLogFilter2dAlgo = new ScaleSpaceLogFilter2d
    {
        inputImage = polystyrene,
        minimumStandardDeviation = new double[]{1.0, 1.0},
        maximumStandardDeviation = new double[]{3.0, 3.0},
        numberOfScales = 1,
        lightness = ScaleSpaceLogFilter2d.Lightness.BRIGHT,
        selectIndexImage = true
    };
    scaleSpaceLogFilter2dAlgo.Execute();

    Console.WriteLine( "outputImage:" + scaleSpaceLogFilter2dAlgo.outputImage.ToString() );
    Console.WriteLine( "scaleTable:" + scaleSpaceLogFilter2dAlgo.scaleTable.ToString() );
    Console.WriteLine( "outputScaleImage:" + scaleSpaceLogFilter2dAlgo.outputScaleImage.ToString() );

## Function Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

    auto result = scaleSpaceLogFilter2d( polystyrene, {1.0, 1.0}, {3.0, 3.0}, 1, ScaleSpaceLogFilter2d::Lightness::BRIGHT, true );

    std::cout << "outputImage:" << result.outputImage->toString();
    std::cout << "scaleTable:" << result.scaleTable->shape();
    std::cout << "outputScaleImage:" << result.outputScaleImage->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    result_output_image, result_scale_table, result_output_scale_image = imagedev.scale_space_log_filter_2d(polystyrene, [1.0, 1.0], [3.0, 3.0], 1, imagedev.ScaleSpaceLogFilter2d.BRIGHT, True)

    print("output_image:", str(result_output_image))
    print("scale_table:", str(result_scale_table))
    print("output_scale_image:", str(result_output_scale_image))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

    Processing.ScaleSpaceLogFilter2dOutput result = Processing.ScaleSpaceLogFilter2d( polystyrene, new double[]{1.0, 1.0}, new double[]{3.0, 3.0}, 1, ScaleSpaceLogFilter2d.Lightness.BRIGHT, true );

    Console.WriteLine( "outputImage:" + result.outputImage.ToString() );
    Console.WriteLine( "scaleTable:" + result.scaleTable.ToString() );
    Console.WriteLine( "outputScaleImage:" + result.outputScaleImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.