handleaiuinew/env/halcon/include/halconcpp/HOperatorOverloads.h

/*****************************************************************************
 * HOperatorOverloads.h
 ***************************************************************************** 
 *
 * Project:     HALCON/C++
 * Description: C++ operator overloads for common class operations
 *
 * (c) 2010-2020 by MVTec Software GmbH
 *                  www.mvtec.com
 * 
 *****************************************************************************
 *
 *
 *****************************************************************************/

#ifndef HCPP_OPERATOR_OVERLOADS_H
#define HCPP_OPERATOR_OVERLOADS_H


namespace HalconCpp
{


/*****************************************************************************
 * HImage: Gray value operations
 *****************************************************************************/
 
// Add gray values
LIntExport HImage operator + (const HImage& image1, const HImage& image2);

// Subtract gray values
LIntExport HImage operator - (const HImage& image1, const HImage& image2);

// Multiply gray values
LIntExport HImage operator * (const HImage& image1, const HImage& image2);

// Shift gray values
LIntExport HImage operator + (const HImage& image, double add);

// Shift gray values
LIntExport HImage operator - (const HImage& image, double sub);

// Scale gray values
LIntExport HImage operator * (const HImage& image, double mult);

// Scale gray values
LIntExport HImage operator / (const HImage& image, double div);

// Shift gray values
LIntExport HImage operator + (double add, const HImage& image);

// Scale gray values
LIntExport HImage operator * (double mult, const HImage& image);


/*****************************************************************************
 * HImage: Segmentation
 *****************************************************************************/

// Dynamic Threshold
LIntExport HRegion operator >= (const HImage& image1, const HImage& image2);

// Dynamic Threshold
LIntExport HRegion operator <= (const HImage& image1, const HImage& image2);

// Fixed Threshold
LIntExport HRegion operator >= (const HImage& image, double threshold);

// Fixed Threshold
LIntExport HRegion operator <= (const HImage& image, double threshold);

// Fixed Threshold
LIntExport HRegion operator >= (double threshold, const HImage& image);

// Fixed Threshold
LIntExport HRegion operator <= (double threshold, const HImage& image);


/*****************************************************************************
 * HImage: Miscellaneous
 *****************************************************************************/

// Reduce domain of image
LIntExport HImage operator & (const HImage& image, const HRegion& region);



/*****************************************************************************
 * HRegion: Sets                                                              *
 *****************************************************************************/

// Intersection of regions
LIntExport HRegion operator & (const HRegion& region1, const HRegion& region2);

// Union of regions
LIntExport HRegion operator | (const HRegion& region1, const HRegion& region2);

// Difference of regions
LIntExport HRegion operator / (const HRegion& region1, const HRegion& region2);

// Intersection of region with image domain
LIntExport HRegion operator & (const HRegion& region, const HImage& image);

// Test if one region is a subset of the other
LIntExport bool   operator >= (const HRegion& region1, const HRegion& region2);

// Test if one region is a subset of the other
LIntExport bool   operator <= (const HRegion& region1, const HRegion& region2);


/*****************************************************************************
 * HRegion: Morphology                                                        *
 *****************************************************************************/

// Minkowski addition of regions
LIntExport HRegion operator + (const HRegion& region1, const HRegion& region2);

// Minkowski substraction of regions
LIntExport HRegion operator - (const HRegion& region1, const HRegion& region2);

// Dilation of region by specified radius
LIntExport HRegion operator + (const HRegion& region, double radius);

// Erosion of region by specified radius
LIntExport HRegion operator - (const HRegion& region, double radius);

// Scaling of region by specified factor
LIntExport HRegion operator * (const HRegion& region, double factor);

// Dilation of region by specified radius
LIntExport HRegion operator + (double radius, const HRegion& region);

// Scaling of region by specified radius
LIntExport HRegion operator * (double factor, const HRegion& region);



/*****************************************************************************
 * HFunction1D
 *****************************************************************************/

// Add a constant offset to the function's Y values
LIntExport HFunction1D operator + (const HFunction1D& function, double add);

// Add a constant offset to the function's Y values
LIntExport HFunction1D operator + (double add, const HFunction1D& function);

// Subtract a constant offset from the function's Y values
LIntExport HFunction1D operator - (const HFunction1D& function, double sub);

// Scale the function's Y values</summary>
LIntExport HFunction1D operator * (const HFunction1D& function, double factor);

// Scale the function's Y values</summary>
LIntExport HFunction1D operator * (double factor, const HFunction1D& function);

// Scale the function's Y values</summary>
LIntExport HFunction1D operator / (const HFunction1D& function, double div);

// Compose two functions (not a pointwise multiplication)</summary>
LIntExport HFunction1D operator * (const HFunction1D& function1, const HFunction1D& function2);



/*****************************************************************************
 * HMatrix
 *****************************************************************************/
 
// Add two matrices
LIntExport HMatrix operator + (const HMatrix& matrix1, const HMatrix& matrix2);

// Subtract two matrices
LIntExport HMatrix operator - (const HMatrix& matrix1, const HMatrix& matrix2);

// Matrix multiplication
LIntExport HMatrix operator * (const HMatrix& matrix1, const HMatrix& matrix2);

// Scale matrix
LIntExport HMatrix operator * (const HMatrix& matrix, double factor);

// Scale matrix
LIntExport HMatrix operator * (double factor, const HMatrix& matrix);

// Solve linear system matrix2 * x = matrix1
LIntExport HMatrix operator / (const HMatrix& matrix1, const HMatrix& matrix2);



/*****************************************************************************
 * HQuaternion
 *****************************************************************************/
 
// Compose two quaternions
LIntExport HQuaternion operator * (const HQuaternion& left, const HQuaternion& right);

/*****************************************************************************
 * HDualQuaternion
 *****************************************************************************/
 
// Compose two dual quaternions
LIntExport HDualQuaternion operator * (const HDualQuaternion& left, const HDualQuaternion& right);



}

#endif