text:
using System;
using System.Collections;
using HalconDotNet;

namespace CalibrationModule
{
    public delegate void CalibDelegate(int value);

    /// <summary>
    /// The calibration assistant serves as a controller class
    /// that coordinates the calibration process and maintains the
    /// communication between the GUI and the calibration data.
    ///
    /// It keeps the set of calibration images <c>CalibData</c> updated and
    /// tracks the calibration parameters. A change in the calibration
    /// parameters provokes an update in the entire set of
    /// <c>CalibImage</c> objects.
    /// Changes in the images are then forwarded to the GUI by
    /// using delegates. Besides changes concerning the graphics window,
    /// also exceptions and errors occurring during processing get
    /// forwarded.
	/// Note that only calibration plates with rectangularly arranged
	/// marks are supported for the Calibration Codelet. The new
	/// HALCON calibration plates with hexagonally arranged marks are
	/// not supported.
    /// </summary>
    public class CalibrationAssistant
	{
        /// <summary>
        /// Constant indicating the camera model to be of type
        /// line scan camera.
        /// </summary>
        public const int  CAMERA_TYP_LINE_SCAN           = 3;
        /// <summary>
        /// Constant indicating the camera model to be of type
        /// area scan camera with the division
        /// model to describe the lens distortions
        /// </summary>
        public const int  CAMERA_TYP_AREA_SCAN_DIV       = 4;
        /// <summary>
        /// Constant indicating the camera model to be of type
        /// area scan camera with the polynomial
        /// model to describe the lens distortions
        /// </summary>
        public const int  CAMERA_TYP_AREA_SCAN_POLY      = 5;

        /// <summary>
        /// Constant indicating a change in the set of
        /// <c>CalibImage</c> instances regarding the parameters
        /// marks and poses.
        /// </summary>
        public const int  UPDATE_MARKS_POSE  	         = 10;
        /// <summary>
        /// Constant indicating a change in the set of
        /// <c>CalibImage</c> instances regarding the
        /// quality assessment.
        /// </summary>
        public const int  UPDATE_QUALITY_TABLE           = 12;
        /// <summary>
        /// Constant indicating a change in the evaluation grades
        /// of the <c>CalibImage</c> set. The grades measure the results
        /// of the calibration preparations prior to the calibration
        /// process itself.
        /// </summary>
        public const int  UPDATE_CALTAB_STATUS           = 13;
        /// <summary>
        /// Constant indicating an update of the calibration
        /// results.
        /// </summary>
        public const int  UPDATE_CALIBRATION_RESULTS     = 14;

        /// <summary>
        /// Constant indicating that the quality measurement
        /// includes all quality assessment operators for
        /// evaluating the set of calibration images.
        /// </summary>
        public const int  QUALITY_ISSUE_TEST_ALL         = 0;
        /// <summary>
        /// Constant indicating that the quality measurement uses only the
        /// basic quality assessment operators for speedup purposes.
        /// </summary>
        public const int  QUALITY_ISSUE_TEST_QUICK       = 1;
        /// <summary>
        /// Constant indicating no quality measurement
        /// for the set of calibration images.
        /// </summary>
        public const int  QUALITY_ISSUE_TEST_NONE        = 2;

        /// <summary>
        /// Constant indicating the image quality feature 'exposure'
        /// </summary>
        public const int  QUALITY_ISSUE_IMG_EXPOSURE     = 20;
        /// <summary>
        /// Constant indicating the image quality feature 'homogeneity'
        /// </summary>
        public const int  QUALITY_ISSUE_IMG_HOMOGENEITY  = 21;
        /// <summary>
        /// Constant indicating the image quality feature 'contrast'
        /// </summary>
        public const int  QUALITY_ISSUE_IMG_CONTRAST     = 22;
        /// <summary>
        /// Constant indicating the image quality feature 'sharpness'
        /// </summary>
        public const int  QUALITY_ISSUE_IMG_FOCUS        = 23;
        /// <summary>
        /// Constant indicating the size of the depicted
        /// calibration plate in the calibration image, to evaluate
        /// the distance used to the camera
        /// </summary>
        public const int  QUALITY_ISSUE_IMG_CALTAB_SIZE  = 24;

        /// <summary>
        /// Constant indicating the coverage of the view field.
        /// This is assured only by a sufficient number of
        /// calibration images and its correct distribution in the space.
        /// </summary>
        public const int  QUALITY_ISSUE_SEQ_MARKS_DISTR  = 25;
        /// <summary>
        /// Constant indicating the amount of distortions covered,
        /// described by the set of images showing tilted calibration
        /// plates
        /// </summary>
        public const int  QUALITY_ISSUE_SEQ_CALTAB_TILT  = 26;
        /// <summary>
        /// Constant indicating whether the number of provided calibration
        /// images is sufficient enough to obtain stable calibration results.
        /// </summary>
        public const int  QUALITY_ISSUE_SEQ_NUMBER       = 27;
        /// <summary>
        /// Constant indicating the all over quality performance,
        /// being best for a value close or equal to 1
        /// </summary>
        public const int  QUALITY_ISSUE_SEQ_ALL_OVER     = 28;
        /// <summary>
        /// Constant that indicates an error in the calibration
        /// preprocessing step, which has to perform well for the
        /// whole sequence of calibration images in order to start
        /// the calibration process.
        /// </summary>
        public const int  QUALITY_ISSUE_SEQ_ERROR        = 29;
        /// <summary>
        /// Constant indicating an error in the preprocessing step
        /// for a single calibration image, i.e., that the
        /// marks and pose values might be missing or the region
        /// plate couldn't be detected
        /// </summary>
        public const int  QUALITY_ISSUE_FAILURE          = 30;

        /// <summary>
        /// Constant describing an error while reading a
        /// calibration image from file
        /// </summary>
        public const int  ERR_READING_FILE               = 31;
        /// <summary>
        /// Constant describing an error exception raised during
        /// the calibration process
        /// </summary>
        public const int  ERR_IN_CALIBRATION             = 32;
        /// <summary>
        /// Constant indicating an invalid reference index. The
        /// index is needed to define the reference image for
        /// the camera calibration.
        /// </summary>
        public const int  ERR_REFINDEX_INVALID           = 33;
        /// <summary>
        /// Constant describing an error exception raised
        /// during quality assessment.
        /// </summary>
        public const int  ERR_QUALITY_ISSUES             = 34;
        /// <summary>
        /// Constant describing an error that occurred while
        /// writing the calibration parameters into file
        /// </summary>
        public const int  ERR_WRITE_CALIB_RESULTS        = 35;

        /// <summary>
        /// Constant indicating the result status of the
        /// calibration preparation step:
        /// Plate region couldn't be detected in the
        /// calibration image.
        /// </summary>
        public const string PS_NOT_FOUND        = "Plate not found";
        /// <summary>
        /// Constant that describes the results of the
        /// calibration preparation step:
        /// Plate region was detected, but the marks could not
        /// be extracted in the plate region.
        /// </summary>
        public const string PS_MARKS_FAILED     = "Marks not found";
        /// <summary>
        /// Constant indicating the result status of the
        /// calibration preparation step:
        /// Plate region and marks were detected,
        /// but the quality assessment delivered bad scores.
        /// </summary>
        public const string PS_QUALITY_ISSUES   = "Quality issues detected";
        /// <summary>
        /// Constant indicating the result status of the
        /// calibration preparation step:
        /// The preprocessing step was successful.
        /// </summary>
        public const string PS_OK               = "Ok";

        /// <summary>
        /// List of calibration images that are used
        /// to perform the camera calibration.
        /// </summary>
        private ArrayList CalibData;
        /// <summary>
        /// Index to the reference image that is used to
        /// determine the initial values for the internal camera
        /// parameters for the camera calibration
        /// </summary>
        public  int       mReferenceIndex;

        private QualityProcedures procedure;

        // CALIBRATION RESULTS -----------------------------------------
        /// <summary>
        /// Flag indicating that the calibration was successful and
        /// the present calibration results are up to date
        /// </summary>
        public  bool      mCalibValid;
        /// <summary>
        /// The average error give an impression of the accuracy of the
        /// calibration. The error (deviations in x and y coordinates) are
        /// measured in pixels
        /// </summary>
        public  double    mErrorMean;

        /// <summary>
        /// Ordered tuple with the external camera parameters for all
        /// calibration images, i.e., the position and orientation of the
        /// calibration plate in camera coordinates.
        /// </summary>
        public  HTuple    mPoses;
        /// <summary>
        /// Internal camera parameters
        /// </summary>
        public  HTuple    mCameraParams;
        /// <summary>
        /// Error contents that caused an exception
        /// </summary>
        public  string    mErrorMessage;

        /// <summary>
        /// Calibration image at index <c>mReferenceIndex</c>
        /// </summary>
        public  HImage   mReferenceImage;
        /// <summary>
        /// Synthetic calibration images with calibrated camera
        /// parameters to test the quality of the calibration
        /// algorithm
        /// </summary>
        public  HImage   mSimulatedImage;
        /// <summary>
        ///  Reference world coordinate system, based on
        ///  <c>mPose</c> and the calibrated camera parameters
        /// </summary>
        public  HObject   mReferenceWCS;

        /// <summary>
        /// Flag describing whether all calibration images
        /// have a sufficient quality, i.e. whether  the region plate and
        /// marks have been detected in all calibration images,
        /// so that a camera calibration can be invoked
        /// </summary>
        public  bool      mCanCalib;
        /// <summary>
        /// Flag indicating that the origin of the reference world coordinate
        /// system <c>mReferenceWCS</c> is mapped to the origin of the image
        /// coordinate system.
        /// </summary>
        public  bool      mAtImgCoord;

        // FIRST TAB  -----------------------------------------------
        /// <summary>
        /// Name of the calibration plate description file to read
        /// the mark center points from
        /// </summary>
        public  string    mDescrFileName;
        /// <summary>
        /// Thickness of the calibration plate that was used in the
        /// calibration images
        /// </summary>
        public  double    mThickness;
        /// <summary>
        /// Camera type, which can either be an area scan camera
        /// (using the division or polynomial model) or a linescan camera
        /// </summary>
        public  int       mCameraType;
        /// <summary>
        /// Horizontal distance between two neighboring CCD
        /// sensor cells
        /// </summary>
        public  double    mCellWidth;    // Sx
        /// <summary>
        /// Vertical distance between two neighboring CCD
        /// sensor cells
        /// </summary>
        public  double    mCellHeight;   // Sy
        /// <summary>
        /// Nominal focal length of the camera lense
        /// </summary>
        public  double    mFocalLength;
        /// <summary>
        /// Parameter to model the radial distortion described by
        /// the division model
        /// </summary>
        public  double    mKappa;
        /// <summary>
        /// First parameter to model the radial distortion described by
        /// the polynomial model
        /// </summary>
        public  double    mK1;
        /// <summary>
        /// Second parameter to model the radial distortion described by
        /// the polynomial model
        /// </summary>
        public  double    mK2;
        /// <summary>
        /// Third parameter to model the radial distortion described by
        /// the polynomial model
        /// </summary>
        public  double    mK3;
        /// <summary>
        /// First parameter to model the decentering distortion described by
        /// the polynomial model
        /// </summary>
        public  double    mP1;
        /// <summary>
        /// Second parameter to model the decentering distortion described by
        /// the polynomial model
        /// </summary>
        public  double    mP2;
        /// <summary>
        /// Flag indicating the type of camera lense used:
        /// telecentric, which means a parallel projection with the focal
        /// length equal to 0, or  a perspective projection
        /// </summary>
        public  bool      isTelecentric;

        /// <summary>
        /// X component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double     mMotionVx;
        /// <summary>
        /// Y component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double     mMotionVy;
        /// <summary>
        /// Z component of the motion vector, which describes the motion
        /// between the linescan camera and the object.
        /// </summary>
        public double     mMotionVz;

        // SECOND TAB ---------------------------------------------
        private int       mWarnLevel;
        private int       mImageTests;
        private int       mSequenceTests;

        /// <summary>
        /// List of quality assessment scores of the whole set of calibration
        /// images.
        /// </summary>
        public ArrayList mSeqQualityList;

        /// <summary>
        /// Size of the filter mask that is used to smooth the
        /// image before determining the region plate in the
        /// calibration image
        /// </summary>
        public  double    mFilterSize;
        /// <summary>
        /// Threshold value for mark extraction
        /// </summary>
        public  double    mMarkThresh;
        /// <summary>
        /// Expected minimum diameter of the marks on the
        /// calibration plate
        /// </summary>
        public  double    mMinMarkDiam;
        /// <summary>
        /// Initial threshold value for contour detection
        /// </summary>
        public  double    mInitThresh;
        /// <summary>
        /// Loop value for successive reduction of
        /// the initial threshold <c>mInitThresh</c>
        /// </summary>
        public  double    mThreshDecr;
        /// <summary>
        /// Minimum threshold for contour detection
        /// </summary>
        public  double    mMinThresh;
        /// <summary>
        /// Filter parameter for contour detection
        /// </summary>
        public  double    mSmoothing;
        /// <summary>
        /// Minimum length of the contours of the marks
        /// </summary>
        public  double    mMinContLength;
        /// <summary>
        /// Maximum expected diameter of the marks
        /// </summary>
        public  double    mMaxMarkDiam;

        // reset vals
        public int     resetFilterSize  = 3;
        public int     resetMarkThresh  = 112;
        public int     resetMinMarkDiam = 5;
        public int     resetInitThresh  = 128;
        public int     resetThreshDecr  = 10;
        public int     resetMinThresh   = 18;
        public double  resetSmoothing   = 0.9; /* 90*0.01 */
        public int     resetMinContL    = 15;
        public int     resetMaxMarkDiam = 100;

        /// <summary>
        /// Delegate to notify the GUI about changes in the data models
        /// </summary>
        public CalibDelegate   NotifyCalibObserver;

      /* Constructor, in which all calibration parameters
       * and  auxiliary variables, flags and lists are initilized */
		public CalibrationAssistant()
		{
            CalibData       = new ArrayList(15);
            mReferenceIndex = -1;
            mDescrFileName  = "caltab_30mm.descr";
            mCalibValid     = false;
            mCanCalib       = true;
            mAtImgCoord     = false;

            mReferenceImage = new HImage();
            mSimulatedImage = new HImage();

            mFilterSize    = resetFilterSize;
            mMarkThresh    = resetMarkThresh;
            mMinMarkDiam   = resetMinMarkDiam;
            mInitThresh    = resetInitThresh;
            mThreshDecr    = resetThreshDecr;
            mMinThresh     = resetMinThresh;
            mSmoothing     = resetSmoothing;
            mMinContLength = resetMinContL;
            mMaxMarkDiam   = resetMaxMarkDiam;

            mWarnLevel      = 70;
            mImageTests     = QUALITY_ISSUE_TEST_ALL;
            mSequenceTests  = QUALITY_ISSUE_TEST_ALL;
            mSeqQualityList = new ArrayList(15);
            procedure       = new QualityProcedures();

            mThickness     = 1.00;       // millimeter
            mCameraType    = CAMERA_TYP_AREA_SCAN_DIV;
            mCellWidth     = 8.300;         // micrometer
            mCellHeight    = 8.300;        // micrometer
            mFocalLength   = 8.000;          // millimeter
            isTelecentric  = false;
            mKappa         = 0.0;
            mK1            = 0.0;
            mK2            = 0.0;
            mK3            = 0.0;
            mP1            = 0.0;
            mP2            = 0.0;
            mMotionVx      = 0.0;
            mMotionVy      = 500.0;
            mMotionVz      = 0.0;

            NotifyCalibObserver = new CalibDelegate(dummy);
        }

        /*******************************************/
        /**********         Tab.1       ************/
        /*******************************************/

        /// <summary>
        /// Sets the reference index to the supplied value
        /// </summary>
        public void setReferenceIdx(int val)
        {
            mReferenceIndex = val;
        }

        /*******************************************/

        /// <summary>
        /// Sets the file path for the description file to
        /// the supplied value
        /// </summary>
        /// <param name="fileName">
        /// Absolute path to the description file
        /// </param>
        public void setDesrcFile(string fileName)
        {
            mDescrFileName = fileName;
            Update();
        }
        /// <summary>
        /// Gets the path to the description file used
        /// with the calibration
        /// </summary>
        public string getDesrcFile()
        {
            return mDescrFileName;
        }

        /*******************************************/

        /// <summary>
        /// Sets the thickness parameter to the supplied value
        /// </summary>
        public void setThickness(double val)
        {
            mThickness = val;
            UpdateResultVisualization();
        }
        /// <summary>
        /// Returns the current value for the thickness of the calibration
        /// plate.
        /// </summary>
        public double getThickness()
        {
            return mThickness;
        }

        /*******************************************/

        /// <summary>
        /// Sets the camera type to the supplied value and
        /// invokes an update to adjust data for the calibration images.
        ///
        /// </summary>
        public void setCameraType(int mode)
        {
            mCameraType = mode;
            Update(true);
        }
        /// <summary>
        /// Returns the current camera type.
        /// </summary>
        public int getCameraType()
        {
            return mCameraType;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the CCD sensor cell width
        /// to the supplied value.
        /// </summary>
        public void setCellWidth(double val)
        {
            mCellWidth = val;
            Update();
        }
        /// <summary>
        /// Returns the value for the CCD sensor cell width
        /// </summary>
        public double getCellWidth()
        {
            return mCellWidth;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the CCD sensor cell height
        /// to the supplied value.
        /// </summary>
        public void setCellHeight(double val)
        {
            mCellHeight = val;
            Update();
        }
        /// <summary>
        /// Returns the value for the CCD sensor cell height
        /// </summary>
        public double getCellHeight()
        {
            return mCellHeight;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the focal length to the
        /// supplied value
        /// </summary>
        public void setFocalLength(double val)
        {
            mFocalLength = val;
            Update();
        }
        /// <summary>
        /// Returns the current value for the focal length
        /// </summary>
        public double getFocalLength()
        {
            return mFocalLength;
        }

        /*******************************************/

        /// <summary>
        /// Sets the boolean flag to indicate the use of telecentric
        /// lense
        /// </summary>
        public void setIsTelecentric(bool val)
        {
            isTelecentric = val;
            Update();
        }
        /// <summary>
        /// Returns whether the current camera lense is  defined to
        /// be telecentric or not
        /// </summary>
        public bool IsTelecentric()
        {
            return isTelecentric;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vx to the supplied
        /// value
        /// </summary>
        public void setMotionX(double val)
        {
            mMotionVx = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vx
        /// </summary>
        public double getMotionX()
        {
            return mMotionVx;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vy to the supplied
        /// value
        /// </summary>
        public void setMotionY(double val)
        {
            mMotionVy = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vy
        /// </summary>
        public double getMotionY()
        {
            return mMotionVy;
        }

        /*******************************************/

        /// <summary>
        /// Sets the motion vector Vz to the supplied
        /// value
        /// </summary>
        public void setMotionZ(double val)
        {
            mMotionVz = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the motion vector Vz
        /// </summary>
        public double getMotionZ()
        {
            return mMotionVz;
        }

        /*******************************************/
        /**********         Tab.2       ************/
        /*******************************************/
        /*******************************************/

        /// <summary>
        /// Sets the parameter for the warn level to
        /// the supplied value.
        /// </summary>
        public void setWarnLevel(int val)
        {
            mWarnLevel = val;
            Update(true);
        }
        /// <summary>
        /// Gets the current value for the warn level
        /// </summary>
        public double getWarnLevel()
        {
            return mWarnLevel;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter to define the mode (accuracy) of
        /// the quality assessment for single
        /// calibration images
        /// </summary>
        /// <param name="mode">
        /// mode (accuracy) of the quality assessment; one of the constants
        /// starting with QUALITY_ISSUE_TEST_*.
        /// </param>
        public void setImageTests(int mode)
        {
            mImageTests = mode;
            Update(true);
        }
        /// <summary>
        /// Gets the current value that describes the
        /// accuracy of the quality assessment
        /// </summary>
        public double getImageTests()
        {
            return mImageTests;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter to define the mode (accuracy) of
        /// the quality assessment for the whole sequence
        /// of calibration images
        /// </summary>
        /// <param name="mode">
        /// mode (accuracy) of the quality assessment; one of the constants
        /// starting with QUALITY_ISSUE_TEST_*.
        /// </param>
        public void setSequenceTests(int mode)
        {
            mSequenceTests = mode;
            Update(true);
        }
        /// <summary>
        /// Gets the current value that describes the
        /// accuracy of the quality assessment
        /// </summary>
        public double getSequenceTests()
        {
            return mSequenceTests;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the filter size to
        /// the supplied value.
        /// </summary>
        public void setFilterSize(double val)
        {
            mFilterSize = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the filter size
        /// </summary>
        public double getFilterSize()
        {
            return mFilterSize;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for mark threshold to
        /// the supplied value.
        /// </summary>
        public void setMarkThresh(double val)
        {
            mMarkThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the mark threshold
        /// </summary>
        public double getMarkThresh()
        {
            return mMarkThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the minimum mark
        /// diameter to the supplied value.
        /// </summary>
        public void setMinMarkDiam(double val)
        {
            mMinMarkDiam = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the minimum mark diameter
        /// </summary>
        public double getMinMarkDiam()
        {
            return mMinMarkDiam;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the start threshold
        /// to the supplied value.
        /// </summary>
        public void setInitThresh(double val)
        {
            mInitThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the start threshold
        /// </summary>
        public double getInitThresh()
        {
            return mInitThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the threshold
        /// decrement to the supplied value.
        /// </summary>
        public void setThreshDecr(double val)
        {
            mThreshDecr = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the threshold decrement
        /// </summary>
        public double getThreshDecr()
        {
            return mThreshDecr;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter for the minimum
        /// threshold to the supplied value.
        /// </summary>
        public void setMinThresh(double val)
        {
            mMinThresh = val;
            Update();
        }
        /// <summary>
        /// Gets the current value for the parameter
        /// describing the minimum threshold
        /// </summary>
        public double getMinThresh()
        {
            return mMinThresh;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the smoothing
        /// factor to the supplied value.
        /// </summary>
        public void setSmoothing(double val)
        {
            mSmoothing = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the smoothing
        /// factor
        /// </summary>
        public double getSmoothing()
        {
            return mSmoothing;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the minimum
        /// contour length to the supplied value.
        /// </summary>
        public void setMinContLength(double val)
        {
            mMinContLength = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the minimum
        /// contour length
        /// </summary>
        public double getMinContLength()
        {
            return mMinContLength;
        }

        /*******************************************/

        /// <summary>
        /// Sets the parameter describing the maximum
        /// mark diameter to the supplied value.
        /// </summary>
        public void setMaxMarkDiam(double val)
        {
            mMaxMarkDiam = val;
            Update();
        }
        /// <summary>
        /// Gets the parameter describing the maximum
        /// mark diameter
        /// </summary>
        public double getMaxMarkDiam()
        {
            return mMaxMarkDiam;
        }

        /*******************************************/

        /// <summary>
        /// Sets the flag defining the origin of
        /// the reference world coordinate system
        /// to be in the image coordinate system
        /// </summary>
        public void setAtImgCoord(bool val)
        {
            mAtImgCoord = val;
            UpdateResultVisualization();

        }
        /// <summary>
        /// Gets the current value for the flag
        /// </summary>
        public bool getAtImgCoord()
        {
            return mAtImgCoord;
        }

        public void dummy(int val){}

        /*******************************************/
        /*******************************************/
        /*******************************************/
        /*******************************************/

        /// <summary>
        /// Gets the calibration image for the index <c>i</c>
        /// from the list <c>CalibData</c>
        /// </summary>
        public CalibImage getCalibDataAt(int i)
        {
            if(CalibData.Count>0)
                return (CalibImage)CalibData[i];
            else
                return null;
        }

        public int getCalibDataLength()
        {
            return CalibData.Count;
        }

        /// <summary>
        /// Add a new calibration image to the list <c>CalibData</c>.
        /// The image is read from the location <c>filename</c>
        /// and a new calibration image instance is then
        /// generated, embedding this image.
        /// As a preparation step prior to the calibration process, the
        /// basic information for the calibration image are determined,
        /// in terms of: detection of the region plate and the marks
        /// and pose.
        /// </summary>
        /// <returns>
        /// Instance of a calibration image model created for
        /// the calibration image, supplied by <c>filename</c>
        /// </returns>
        public CalibImage addImage(string filename)
        {
            HImage     image = null;
            CalibImage data = null;

            try
            {
                image = new HImage(filename);
                data  = new CalibImage(image, this);
                CalibData.Add(data);
                data.UpdateCaltab(true);
                mCanCalib = (mCanCalib && (data.mCanCalib==0));
                mCalibValid = false;
            }
            catch(HOperatorException e)
            {
                mErrorMessage = e.Message;
                NotifyCalibObserver(CalibrationAssistant.ERR_READING_FILE);
            }

            return data;
        }

        /// <summary>
        /// Removes the instance of the calibration images
        /// at the index <c>index</c> from the list <c>CalibData</c>
        /// </summary>
        public void removeImage(int index)
        {
            ((CalibImage)CalibData[index]).Clear();
            CalibData.RemoveAt(index);
            mCalibValid = false;
            getCanCalibrate();
            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Removes all instances of the calibration images
        /// from the list <c>CalibData</c>
        /// </summary>
        public void removeImage()
        {
            int count = CalibData.Count;
            for(int i=0; i<count;i++)
                ((CalibImage)CalibData[i]).Clear();

            CalibData.Clear();
            mCalibValid = false;
            mCanCalib = false;
            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Gets the HALCON image with the index <c>index</c> in the list of
        /// calibration images <c>CalibData</c>.
        /// </summary>
        public HImage getImageAt(int index)
        {
            if(CalibData.Count>0)
                return ((CalibImage)CalibData[index]).getImage();
            return null;
        }

        /// <summary>
        /// Resets the flag <c>mCanCalib</c> to the boolean 'true'
        /// </summary>
        public void resetCanCalib()
        {
            mCanCalib = true;
        }

        /// <summary>
        /// Returns the reference image for the calibration process
        /// </summary>
        public HImage getRefImage()
        {
            return (HImage)mReferenceImage;
        }

        /// <summary>
        /// Returns the simulated image obtained from
        /// the calibration process
        /// </summary>
        public HImage getSimulatedImage()
        {
            return mSimulatedImage;
        }

        /// <summary>
        /// Returns the reference world coordinate system
        /// obtained from the calibration process
        /// </summary>
        /// <returns></returns>
        public HObject getReferenceWCS()
        {
            return mReferenceWCS;
        }

        /*******************************************/

        /// <summary>
        /// Auxiliary method prior to the actual update
        /// routine. Calls the actual update method
        /// omitting the quality assessment for the
        /// set of calibration image models.
        /// </summary>
        public void Update()
        {
            bool doQuality = false;
            Update(doQuality);
        }

        /// <summary>
        /// Updates the data of the calibration images
        /// if a change occurred in the calibration parameters.
        /// The quality assessment is performed if the
        /// supplied value is positive; otherwise, it is omited.
        /// </summary>
        /// <param name="doQuality">
        /// If the flag is positive, an update of the
        /// quality assessment is invoked, otherwise not.
        /// </param>
        public void Update(bool doQuality)
        {
            int  count;

            if((count=CalibData.Count) == 0)
                return;

            try
            {
                for(int i=0; i<count;i++)
                    ((CalibImage)CalibData[i]).UpdateCaltab(doQuality);

                if(doQuality)
                    UpdateSequenceIssues();

                mCanCalib = getCanCalibrate();

                NotifyCalibObserver(CalibrationAssistant.UPDATE_CALTAB_STATUS);
                NotifyCalibObserver(CalibrationAssistant.UPDATE_MARKS_POSE);

                if(doQuality)
                    NotifyCalibObserver(CalibrationAssistant.UPDATE_QUALITY_TABLE);
            }
            catch(HOperatorException e)
            {
                mErrorMessage = (string)e.Message;
                mCanCalib     = false;
                NotifyCalibObserver(CalibrationAssistant.ERR_QUALITY_ISSUES);
            }

            if(mCalibValid)
            {
                mCalibValid = false;
                NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
            }
        }

        /*******************************************/

        /// <summary>
        /// Checks the whole set of calibration image models for
        /// the quality of the preprocessing step. If the basic
        /// information, i.e. the region plate and the marks
        /// and pose, was extracted in all images, then the
        /// flag <c>mCanCalib</c> is positive, which means
        /// the actual calibration process can be initiated
        /// </summary>
        /// <returns>
        /// Flag indicating the feasibility of the calibration
        /// process
        /// </returns>
        public bool getCanCalibrate()
        {
            int count = CalibData.Count;
            int val   = 0;

            for(int i=0; i<count; i++)
                val+= ((CalibImage)CalibData[i]).mCanCalib;

            if(val==0 && count > 0)
                mCanCalib = true;
            else
                mCanCalib = false;

            return mCanCalib;
        }

        /// <summary>
        /// Gets the mark centers and the poses extracted from
        /// the set of calibration images
        /// </summary>
        /// <param name="rows">
        /// Tuple of row coordinates of all marks from
        /// the entire set of calibration images
        /// </param>
        /// <param name="cols">
        /// Tuple of column coordinates of all marks from
        /// the entire set of calibration images
        /// </param>
        /// <returns>
        /// Tuple of estimated poses for the entire set
        /// of calibration images
        /// </returns>
        public HTuple getCalibrationData(out HTuple rows, out HTuple cols)
        {
            int count   = CalibData.Count;
            HTuple pose = new HTuple();
            rows        = new HTuple();
            cols        = new HTuple();
            CalibImage image;

            for(int i = 0; i<count; i++)
            {
                image = (CalibImage)CalibData[i];
                pose = pose.TupleConcat(image.getEstimatedPose());
                rows = rows.TupleConcat(image.getMarkCenterRows());
                cols = cols.TupleConcat(image.getMarkCenterColumns());
            }
            return pose;
        }

        /// <summary>
        /// Gets the camera parameters corresponding to
        /// the supplied calibration image.
        /// </summary>
        /// <returns>Camera parameters</returns>
        public HTuple getCameraParams(CalibImage image)
        {
            HTuple campar;
            int  paramsListSize = 8;
            int  offset         = 0;
            bool areaScanPoly   = false;

            if(mCameraType==CalibrationAssistant.CAMERA_TYP_AREA_SCAN_POLY)
            {
                paramsListSize  = 12;
                offset          = 4;
                areaScanPoly    = true;
            }

            paramsListSize += (mCameraType==CalibrationAssistant.CAMERA_TYP_LINE_SCAN)?3:0;

            campar    = new HTuple(paramsListSize);
            campar[0] = (isTelecentric? 0.0: ((double)mFocalLength/1000.0));

            if(areaScanPoly)
            {
                campar[1] =  mK1;
                campar[2] =  mK2;
                campar[3] =  mK3;
                campar[4] =  mP1;
                campar[5] =  mP2;
            }
            else
            {
                campar[1] =  mKappa;
            }

            campar[2+offset] = (double)mCellWidth/1000000.0;   // Sx -width   -> * 10^ -6
            campar[3+offset] = (double)mCellHeight/1000000.0;  // Sy -height  -> * 10^ -6
            campar[4 + offset] = (double)image.mWidth * 0.5;                  // x -principal point
            campar[5 + offset] = (double)image.mHeight * 0.5;                 // y -principal point
            campar[6+offset] = image.mWidth;                      // imagewidth
            campar[7+offset] = image.mHeight;                     // imageheight

            if(paramsListSize==11)
            {
                campar[8] = mMotionVx/1000000.0;
                campar[9] = mMotionVy/1000000.0;
                campar[10]= mMotionVz/1000000.0;

                campar[5+offset] = 0;     // y -principal point = 0 for line scan camera
            }

            return campar;
        }

        /// <summary>
        /// Tests different quality features for the calibration image
        /// <c>cImg</c>
        /// </summary>
        /// <returns>
        /// Returns a value indicating the success or failure
        /// of the quality assessment
        /// </returns>
        public bool testQualityIssues(CalibImage cImg)
        {
            ArrayList qList;

            HObject markContours;
            HObject plateRegion;
            HImage  mImg;
            HTuple  score, score2, contrast;
            int  numRegions, numContours;
            bool qualityFailure;

            mImg            = cImg.getImage();
            qList           = cImg.getQualityIssueList();
            procedure       = new QualityProcedures();
            contrast        = new HTuple();
            qualityFailure  = false;
            // DescriptionFileName = mDescrFileName;
            ;

            try
            {
                procedure.find_caltab_edges(mImg, out plateRegion,
                                            out markContours,
                                            new HTuple(mDescrFileName));
                numRegions   = plateRegion.CountObj();
                numContours  = markContours.CountObj();

                if(mImageTests < QUALITY_ISSUE_TEST_NONE)
                {
                    if(numRegions == 0)
                    {
                        qualityFailure = true;
                    }
                    else
                    {
                        procedure.eval_caltab_overexposure(mImg, plateRegion, out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_EXPOSURE, score.D);
                    }

                    if(numContours == 0)
                    {
                        qualityFailure = true;
                    }
                    else
                    {
                        procedure.eval_caltab_contrast_homogeneity(mImg, markContours,out contrast, out score, out score2);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_CONTRAST,    score.D);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_HOMOGENEITY, score2.D);

                        procedure.eval_caltab_size(mImg, plateRegion, markContours, out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_CALTAB_SIZE, score.D);
                    }

                    if(mImageTests == QUALITY_ISSUE_TEST_ALL)
                    {
                        procedure.eval_caltab_focus(mImg, markContours,contrast , out score);
                        addQualityIssue(qList, QUALITY_ISSUE_IMG_FOCUS, score.D);
                    }
                }
            }
            catch(HOperatorException e)
            {
                throw(e);
            }

            return qualityFailure;
        }

        /// <summary>
        /// Tests for quality features concerning the performance
        /// of the entire sequence of calibration images provided by
        /// the list <c>CalibData</c>
        /// </summary>
        public void UpdateSequenceIssues()
        {
            HTuple markRows, marksCols, startPose, width, height, hScore;
            bool hasIssue;
            bool hasError;
            double minScore, score;
            int count, countL;
            CalibImage imgC;
            ArrayList qList;

            mSeqQualityList.Clear();

            try
            {
                if(mSequenceTests < QUALITY_ISSUE_TEST_NONE)
                {
                    hasIssue = false;
                    hasError = false;
                    minScore   = 1.0;

                    if((count=CalibData.Count) == 0)
                        return;

                    for(int i=0; i<count;i++)
                    {
                        imgC =(CalibImage)CalibData[i];

                        if(imgC.getPlateStatus() == PS_QUALITY_ISSUES)
                        {
                            hasIssue = true;
                            qList = imgC.getQualityIssueList();
                            countL = qList.Count;

                            for(int j=0; j<countL;j++)
                            {
                                score = ((QualityIssue)qList[j]).getScore();

                                if(score < minScore)
                                    minScore = score;
                            }
                        }
                        else if(imgC.getPlateStatus() != PS_OK)
                        {
                            hasError = true;
                        }
                    }//for

                    if(hasError)
                    {
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_ERROR, 0.0);
                    }
                    else if(hasIssue)
                    {
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_ALL_OVER, minScore);
                    }

                    if(count < 20)
                    {
                        score = (count<=10)? 0.0:(0.1*((double)count-10.0));
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_NUMBER, score);
                    }

                    if(mSequenceTests == QUALITY_ISSUE_TEST_ALL && count>0)
                    {
                        startPose = getCalibrationData(out markRows, out marksCols);
                        width     = new HTuple(((CalibImage)CalibData[0]).mWidth);
                        height    = new HTuple(((CalibImage)CalibData[0]).mHeight);

                        procedure.eval_marks_distribution(markRows, marksCols, width, height, out hScore);
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_MARKS_DISTR, hScore[0].D);

                        procedure.eval_caltab_tilt(startPose, out hScore);
                        addQualityIssue(mSeqQualityList, QUALITY_ISSUE_SEQ_CALTAB_TILT, hScore[0].D);
                    }
                }//if!=None
            }
            catch(HOperatorException e)
            {
                mErrorMessage = e.Message;
            }
        }

        /// <summary>
        /// Adds the calculated score <c>score</c> for the quality feature
        /// <c>type</c> to the supplied feature list <c>qList</c>
        /// </summary>
        /// <param name="qList">
        /// Quality feature list
        /// </param>
        /// <param name="type">
        /// Constant starting with QUALITY_*, describing one of the quality
        /// features
        /// </param>
        /// <param name="score">
        /// Score determined for the quality feature
        /// </param>
        public void addQualityIssue(ArrayList qList, int type, double score)
        {
           if((int)(score*100)<= mWarnLevel)
               qList.Add(new QualityIssue(type, score));
        }

        /// <summary>
        /// Calls the actual <c>addQualityIssue</c>
        /// method, with the feature list obtained from the
        /// calibration image <c>cImg</c>
        /// </summary>
        /// <param name="cImg">
        /// Calibration image model, which has been tested for
        /// the quality feature defined with <c>type</c>
        /// </param>
        /// <param name="type">
        /// Constant starting with QUALITY_* describing one of the quality
        /// features
        /// </param>
        /// <param name="score">
        /// Score determined for the quality feature
        /// </param>
        public void addQualityIssue(CalibImage cImg, int type, double score)
        {
            ArrayList qList = cImg.getQualityIssueList();
            addQualityIssue(qList, type, score);
        }

        /// <summary>
        /// Applies the calibration on the set of calibration
        /// images <c>CalibData</c>
        /// </summary>
        public void applyCalibration()
        {
            HTuple       x,y,z,marksR,marksC;
            HTuple       error, startPoses, startCampar, parameters;
            CalibImage   refImg;

            mCalibValid = false;
            mErrorMean  = -1;

            if(mReferenceIndex >=0)
            {
                try
                {
                    refImg = (CalibImage)CalibData[mReferenceIndex];
                    HOperatorSet.CaltabPoints(mDescrFileName, out x, out y, out z);
                    startPoses  = getCalibrationData(out marksR, out marksC);
                    startCampar = getCameraParams(refImg);
                    parameters  = new HTuple("all");

                    HOperatorSet.CameraCalibration(x, y, z,
                                                   marksR, marksC,
                                                   startCampar,
                                                   startPoses,
                                                   parameters,
                                                   out mCameraParams,
                                                   out mPoses,
                                                   out error);
                    mErrorMean = error[0].D;
                    mCalibValid = true;

                    UpdateResultVisualization();
                }
                catch(HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_IN_CALIBRATION);
                }
            }
            else
            {
                NotifyCalibObserver(CalibrationAssistant.ERR_REFINDEX_INVALID);
            }//if-else
        }

        /// <summary>
        /// Generates the iconic objects of the calibration results
        /// for display
        /// </summary>
        public void UpdateResultVisualization()
        {
            HTuple refPose, correctedPose;
            double axisLen;
            HObject obj;

            if(!mCalibValid)
                return;

            mSimulatedImage.Dispose();

            mReferenceImage = ((CalibImage)CalibData[mReferenceIndex]).getImage();
            refPose         = getCalibratedPose(false);

            HOperatorSet.SimCaltab(out obj, new HTuple(mDescrFileName),
                                   mCameraParams, refPose, new HTuple(128),
                                   new HTuple(224), new HTuple(80), new HTuple(1));

            mSimulatedImage = new HImage(obj);

            correctedPose = getCalibratedPose(true);
            axisLen       = ((CalibImage)CalibData[mReferenceIndex]).getEstimatedPlateSize();

            procedure.get_3d_coord_system(mReferenceImage, out mReferenceWCS, mCameraParams,
                                          correctedPose, new HTuple(axisLen/2));

            NotifyCalibObserver(CalibrationAssistant.UPDATE_CALIBRATION_RESULTS);
        }

        /// <summary>
        /// Saves the calibrated camera parameters in the file
        /// defined by <c>filename</c>
        /// </summary>
        public void saveCamParams(string filename)
        {
            if(mCalibValid)
            {
                try
                {
                    HOperatorSet.WriteCamPar(mCameraParams, new HTuple(filename));
                }
                catch(HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_WRITE_CALIB_RESULTS);
                }
            }
        }

        /// <summary>
        /// Saves the pose obtained from the camera calibration
        /// in the file, defined by <c>filename</c>
        /// </summary>
        public void saveCamPose(string filename)
        {
            HTuple Pose;
            if(mCalibValid)
            {
                try
                {
                    Pose = getCalibratedPose(true);
                    HOperatorSet.WritePose(Pose, new HTuple(filename));
                }
                catch(HOperatorException e)
                {
                    mErrorMessage = e.Message;
                    NotifyCalibObserver(CalibrationAssistant.ERR_WRITE_CALIB_RESULTS);
                }
            }
        }

        /// <summary>
        /// Returns calibration results
        /// </summary>
        /// <param name="camParams">
        /// Calibrated internal camera parameters
        /// </param>
        /// <param name="refPose">
        /// Calibrated external camera parameters
        /// </param>
        public void getCalibrationResult(out HTuple camParams,
                                           out HTuple refPose)
        {
            camParams = new HTuple(mCameraParams);
            refPose   = getCalibratedPose(true);
        }

        /// <summary>
        /// Returns the calibrated reference pose
        /// </summary>
        public HTuple getCalibratedPose(bool corrected)
        {
            HTuple tX, tY, tZ, correctedPose, refPose=null;

            if(!mCalibValid)
                return new HTuple(1.0, -1.0, 0.0);

            if(mPoses.Length >= 7*(mReferenceIndex+1))
               refPose =  mPoses.TupleSelectRange(new HTuple(7*mReferenceIndex),
                                                  new HTuple(7*mReferenceIndex+6));

            if(!corrected)
                return refPose;

            tX = new HTuple(0);
            tY = new HTuple(0);
            tZ = new HTuple(this.mThickness / 1000.0);

            if(mAtImgCoord)
            {
                HOperatorSet.ImagePointsToWorldPlane(mCameraParams, refPose,
                                                    new HTuple(0), new HTuple(0),
                                                    new HTuple("m"), out tX, out tY);
            }
            HOperatorSet.SetOriginPose(refPose, tX, tY, tZ, out correctedPose);

            return correctedPose;
        }

        /// <summary>Loads camera parameters from file</summary>
        /// <param name="camParFile">File name</param>
        /// <returns>Success or failure of load process</returns>
        public bool importCamParams(string camParFile)
        {
            HTuple campar;
            int    offset = 0;
            bool   areaScanPoly = false;

            try
            {
                HOperatorSet.ReadCamPar(new HTuple(camParFile), out campar);

                // -- load camera parameters --
                switch(campar.Length)
                {
                    case 8:
                        mCameraType = CAMERA_TYP_AREA_SCAN_DIV;
                        break;
                    case 11:
                        mCameraType = CAMERA_TYP_LINE_SCAN;
                        break;
                    case 12:
                        mCameraType = CAMERA_TYP_AREA_SCAN_POLY;
                        offset = 4;
                        areaScanPoly = true;
                        break;
                    default:
                        mCameraType = -1;
                        break;
                }

                mFocalLength  = campar[0]*1000.0;

                if(mFocalLength==0.0)
                    isTelecentric = true;
                else
                    isTelecentric = false;

                if(areaScanPoly)
                {
                    mK1 = campar[1];
                    mK2 = campar[2];
                    mK3 = campar[3];
                    mP1 = campar[4];
                    mP2 = campar[5];
                }
                else
                {
                    mKappa =  campar[1];
                }

                mCellWidth  = campar[2+offset]*1000000.0;
                mCellHeight = campar[3+offset]*1000000.0;

                // line scan camera
                if(campar.Length==11)
                {
                    mMotionVx = campar[8].D *1000000.0;
                    mMotionVy = campar[9].D *1000000.0;
                    mMotionVz = campar[10].D*1000000.0;
                }

                Update(true);
            }
            catch(HOperatorException e)
            {
                mErrorMessage = e.Message;
                NotifyCalibObserver(CalibrationAssistant.ERR_READING_FILE);
                return false;
            }

            return true;
        }

        /// <summary>
        /// Resets the camera parameters to the default settings.
        /// </summary>
        /// <param name="camTyp">
        /// Flag to change camera type to the default as well
        /// </param>
        public void resetCameraSetup(bool camTyp)
        {
            if(camTyp)
                mCameraType    = CAMERA_TYP_AREA_SCAN_DIV;

            mThickness     = 1.00;
            mCellWidth     = 8.300;
            mCellHeight    = 8.300;
            mFocalLength   = 8.000;
            isTelecentric  = false;
            mKappa         = 0.0;
            mK1            = 0.0;
            mK2            = 0.0;
            mK3            = 0.0;
            mP1            = 0.0;
            mP2            = 0.0;
            mMotionVx      = 0.0;
            mMotionVy      = 500.0;
            mMotionVz      = 0.0;

            Update(true);
        }

    }//end of class
}//end of namespace


text:
<?hh //strict

namespace Quadtree;

class CollisionDetector implements \Quadtree\ICollisionDetector
{
    public function intersects(Geometry\Bounds $bounds, Insertable $item) : bool
    {
        return $bounds->getBounds()->intersects($item->getBounds());
    }

    public function collide(array<Insertable> $insertedItems, Insertable $item) : bool
    {
        foreach ($insertedItems as $insertedItem) {
            if ($insertedItem->getBounds()->intersects($item->getBounds())) {
                return true;
            }
        }
        return false;
    }
}

redpajama_set_name: RedPajamaGithub


text:
module Config
  class CoffeeScript < Base
    private

    def parse(file_content)
      result = Parser.json(file_content)

      ensure_correct_type(result)
    end

    def linter_config
      super || hound_config.content[alternate_linter_name]
    end

    def alternate_linter_name
      linter_name.sub('_', '')
    end
  end
end


text:
import DefaultLayout from '../components/DefaultLayout'
import PageHeader from '../components/PageHeader'

function Error () {
  return (
    <DefaultLayout title='Not Found'>

        <PageHeader subTitle='An error occurred' title='Not Found' />

Sorry, we couldn't find this page, please go back

    </DefaultLayout>
  )
}

export default Error


text:
<?php

/**
 * This file is part of the Phorm project.
 */

namespace Phorm\Element;

/**
 * Class Raw
 *
 * @package Phorm\Element
 * @author Bo Thinggaard <bo@unpossiblesystems.com>
 */
class Raw extends Content {

}


text:
package org.drip.analytics.definition;

/*
 * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 */

/*!
 * Copyright (C) 2014 Lakshmi Krishnamurthy
 * Copyright (C) 2013 Lakshmi Krishnamurthy
 * Copyright (C) 2012 Lakshmi Krishnamurthy
 * Copyright (C) 2011 Lakshmi Krishnamurthy
 *
 *  This file is part of DRIP, a free-software/open-source library for fixed income analysts and developers -
 * 		http://www.credit-trader.org/Begin.html
 *
 *  DRIP is a free, full featured, fixed income rates, credit, and FX analytics library with a focus towards
 *  	pricing/valuation, risk, and market making.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *   	you may not use this file except in compliance with the License.
 *
 *  You may obtain a copy of the License at
 *  	http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  	distributed under the License is distributed on an "AS IS" BASIS,
 *  	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *
 *  See the License for the specific language governing permissions and
 *  	limitations under the License.
 */

/**
 * FXBasisCurve implements the curve representing the FXBasis nodes. It extends the Curve class, and exposes
 * 	the following functionality:
 * 	- Retrieve the spot parameters (FX Spot, Spot Date, and the currency pair)
 *  - Indicate if the basis has been bootstrapped
 *  - Calculate the Complete set of FX Forward corresponding to each basis node
 *
 * @author Lakshmi Krishnamurthy
 */

public abstract class FXBasisCurve extends org.drip.service.stream.Serializer implements
	org.drip.analytics.definition.Curve {

	/**
	 * Returns the Spot Date
	 *
	 * @return Spot Date
	 */

	public abstract org.drip.analytics.date.JulianDate spotDate();

	/**
	 * Get the FX Spot
	 *
	 * @return FX Spot
	 */

	public abstract double fxSpot();

	/**
	 * Return the currency pair instance
	 *
	 * @return CurrencyPair object instance
	 */

	public abstract org.drip.product.params.CurrencyPair currencyPair();

	/**
	 * Return if the inputs are for bootstrapped FX basis
	 *
	 * @return True if the inputs are for bootstrapped FX basis
	 */

	public abstract boolean isBasisBootstrapped();

	/**
	 * Return the array of full FX Forwards
	 *
	 * @param valParam ValuationParams
	 * @param dcNum Discount Curve Numerator
	 * @param dcDenom Discount Curve Numerator
	 * @param bBasisOnDenom True if the basis is on the denominator
	 * @param bFwdAsPIP True if the FX Forwards are to represented as PIP
	 *
	 * @return Array of FXForward
	 */

	public abstract double[] fxForward (
		final org.drip.param.valuation.ValuationParams valParam,
		final org.drip.analytics.rates.DiscountCurve dcNum,
		final org.drip.analytics.rates.DiscountCurve dcDenom,
		final boolean bBasisOnDenom,
		final boolean bFwdAsPIP);
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Documents;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Media.Imaging;

namespace Controls.Toolkit
{
    public sealed class MasonryItem : Control
    {
        public event EventHandler<MasonryItemClickArgs> ItemButtonClick;

        public double ItemWidth
        {
            get { return (double)GetValue(ItemWidthProperty); }
            set { SetValue(ItemWidthProperty, value); }
        }

        public static readonly DependencyProperty ItemWidthProperty =
            DependencyProperty.Register("ItemWidth", typeof(double), typeof(MasonryItem), new PropertyMetadata(0));

        public double ItemHeight
        {
            get { return (double)GetValue(ItemHeightProperty); }
            set { SetValue(ItemHeightProperty, value); }
        }

        public static readonly DependencyProperty ItemHeightProperty =
            DependencyProperty.Register("ItemHeight", typeof(double), typeof(MasonryItem), new PropertyMetadata(0));

        public object Content
        {
            get { return (object)GetValue(ContentProperty); }
            set { SetValue(ContentProperty, value); }
        }

        public static readonly DependencyProperty ContentProperty =
            DependencyProperty.Register("Content", typeof(object), typeof(MasonryItem), new PropertyMetadata(null));

        public DisplayMode DisplayMode
        {
            get { return (DisplayMode)GetValue(DisplayModeProperty); }
            set { SetValue(DisplayModeProperty, value); }
        }

        public static readonly DependencyProperty DisplayModeProperty =
            DependencyProperty.Register("DisplayMode", typeof(DisplayMode), typeof(MasonryItem), new PropertyMetadata(DisplayMode.Image));

        public int Id
        {
            get { return (int)GetValue(IdProperty); }
            set { SetValue(IdProperty, value); }
        }

        public static readonly DependencyProperty IdProperty =
            DependencyProperty.Register("Id", typeof(int), typeof(MasonryItem), new PropertyMetadata(0));

        public string ImageSource
        {
            get { return (string)GetValue(IamgeSourceProperty); }
            set { SetValue(IamgeSourceProperty, value); }
        }

        public static readonly DependencyProperty IamgeSourceProperty =
            DependencyProperty.Register("ImageSource", typeof(string), typeof(MasonryItem), new PropertyMetadata(string.Empty, (s, e) =>
            {
                if (s != null && e.NewValue != null)
                {
                    (s as MasonryItem).SetContent();
                }
            }));

        public void SetContent()
        {
            if (this.DisplayMode == DisplayMode.Image)
            {
                this.Content = new Image() { Source = new BitmapImage(new Uri(this.ImageSource, UriKind.RelativeOrAbsolute) { }), Stretch = Stretch.UniformToFill };
            }
            else if (this.DisplayMode == Toolkit.DisplayMode.Button)
            {
                Image img = new Image() { Source = new BitmapImage(new Uri(this.ImageSource, UriKind.RelativeOrAbsolute) { }), Stretch = Stretch.UniformToFill };
                Button btn = new Button() { Margin = new Thickness(0), Padding = new Thickness(0), Content = img };
                btn.Click += btn_Click;
                this.Content = btn;
            }
        }

        void btn_Click(object sender, RoutedEventArgs e)
        {
            if (this.ItemButtonClick != null)
            {
                this.ItemButtonClick(this, new MasonryItemClickArgs() { ItemID = this.Id });
            }
        }

        public void CleanUp()
        {
            if (this.Content == null)
                return;
            if (this.Content is Button)
            {
                Button btn = this.Content as Button;
                btn.Click -= btn_Click;
                Image img = btn.Content as Image;
                if (img != null)
                {
                    BitmapImage bitmap = img.Source as BitmapImage;
                    bitmap.UriSource = null;
                    bitmap = null;
                    img.Source = null;
                    img = null;
                }
                this.Content = null;
                return;
            }
            else if (this.Content is Image)
            {
                Image img = this.Content as Image;
                if (img != null)
                {
                    BitmapImage bitmap = img.Source as BitmapImage;
                    bitmap.UriSource = null;
                    bitmap = null;
                    img.Source = null;
                    img = null;
                }
                this.Content = null;
                return;
            }
            else
            {
                this.Content = null;
            }

        }

        public MasonryItem()
        {
            this.DefaultStyleKey = typeof(MasonryItem);
        }

        public MasonryItem(double itemWidth, double itemHeight, string imageSource, DisplayMode displaymode = DisplayMode.Image)
        {
            this.DefaultStyleKey = typeof(MasonryItem);
            this.ItemWidth = itemWidth;
            this.ItemHeight = itemHeight;
            this.ImageSource = imageSource;
            this.DisplayMode = displaymode;
        }
    }
    public class MasonryItemClickArgs : EventArgs
    {
        public int ItemID { get; set; }
    }

    public enum DisplayMode
    {
        Image = 0,
        Button = 1,
        Content = 2,
    }
}


text:
Anyone is welcome to review pull requests. Besides our [technical requirements](https://github.com/helm/charts/blob/master/CONTRIBUTING.md#technical-requirements) and [best practices](https://github.com/helm/helm/tree/master/docs/chart_best_practices), here's an overview of process and review guidelines.

## Process

The process to get a pull request merged is fairly simple. First, all required tests need to pass and the contributor needs to have a signed [DCO](https://www.helm.sh/blog/helm-dco/index.html). See [Charts Testing](https://github.com/helm/charts/blob/master/test/README.md) for details on our CI system and how you can provide custom values for testing. If there is a problem with some part of the test, such as a timeout issue, please contact one of the charts repository maintainers by commenting `cc @helm/charts-maintainers`.

The charts repository uses the OWNERS files to provide merge access. If a chart has an OWNERS file, an approver listed in that file can approve the pull request. If the chart does not have an OWNERS file, an approver in the OWNERS file at the root of the repository can approve the pull request.

To approve the pull request, an approver needs to leave a comment of `/lgtm` on the pull request. Once this is in place some tags (`lgtm` and `approved`) will be added to the pull request and a bot will come along and perform the merge.

Note, if a reviewer who is not an approver in an OWNERS file leaves a comment of `/lgtm` a `lgtm` label will be added but a merge will not happen.

## Immutability

Chart releases must be immutable. Any change to a chart warrants a chart version bump even if it is only changes to the documentation.

## Chart Metadata

The `Chart.yaml` should be as complete as possible. The following fields are mandatory:

* name (same as chart's directory)
* home
* version
* appVersion
* description
* maintainers (name should be Github username)

## Dependencies

Stable charts should not depend on charts in incubator.

## Names and Labels

### Metadata
Resources and labels should follow some conventions. The standard resource metadata (`metadata.labels` and `spec.template.metadata.labels`) should be this:

```yaml
name: {{ include "myapp.fullname" . }}
labels:
  app.kubernetes.io/name: {{ include "myapp.name" . }}
  app.kubernetes.io/instance: {{ .Release.Name }}
  app.kubernetes.io/managed-by: {{ .Release.Service }}
  helm.sh/chart: {{ include "myapp.chart" . }}
```

If a chart has multiple components, a `app.kubernetes.io/component` label should be added (e. g. `app.kubernetes.io/component: server`). The resource name should get the component as suffix (e. g. `name: {{ include "myapp.fullname" . }}-server`).

Note that templates have to be namespaced. With Helm 2.7+, `helm create` does this out-of-the-box. The `app.kubernetes.io/name` label should use the `name` template, not `fullname` as is still the case with older charts.

### Deployments, StatefulSets, DaemonSets Selectors

`spec.selector.matchLabels` must be specified should follow some conventions. The standard selector should be this:

```yaml
selector:
  matchLabels:
    app.kubernetes.io/name: {{ include "myapp.name" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
```

If a chart has multiple components, a `component` label should be added to the selector (see above).

`spec.selector.matchLabels` defined in `Deployments`/`StatefulSets`/`DaemonSets` `>=v1/beta2` **must not** contain `helm.sh/chart` label or any label containing a version of the chart, because the selector is immutable.
The chart label string contains the version, so if it is specified, whenever the the Chart.yaml version changes, Helm's attempt to change this immutable field would cause the upgrade to fail.

#### Fixing Selectors

##### For Deployments, StatefulSets, DaemonSets apps/v1beta1 or extensions/v1beta1

- If it does not specify `spec.selector.matchLabels`, set it
- Remove `helm.sh/chart` label in `spec.selector.matchLabels` if it exists
- Bump patch version of the Chart

##### For Deployments, StatefulSets, DaemonSets >=apps/v1beta2

- Remove `helm.sh/chart` label in `spec.selector.matchLabels` if it exists
- Bump major version of the Chart as it is a breaking change

### Service Selectors

Label selectors for services must have both `app.kubernetes.io/name` and `app.kubernetes.io/instance` labels.

```yaml
selector:
  app.kubernetes.io/name: {{ include "myapp.name" . }}
  app.kubernetes.io/instance: {{ .Release.Name }}
```

If a chart has multiple components, a `app.kubernetes.io/component` label should be added to the selector (see above).

### Persistence Labels

### StatefulSet

In case of a `Statefulset`, `spec.volumeClaimTemplates.metadata.labels` must have both `app.kubernetes.io/name` and `app.kubernetes.io/instance` labels, and **must not** contain `helm.sh/chart` label or any label containing a version of the chart, because `spec.volumeClaimTemplates` is immutable.

```yaml
labels:
  app.kubernetes.io/name: {{ include "myapp.name" . }}
  app.kubernetes.io/instance: {{ .Release.Name }}
```

If a chart has multiple components, a `app.kubernetes.io/component` label should be added to the selector (see above).

### PersistentVolumeClaim

In case of a `PersistentVolumeClaim`, unless special needs, `matchLabels` should not be specified
because it would prevent automatic `PersistentVolume` provisioning.

## Formatting

* Yaml file should be indented with two spaces.
* List indentation style should be consistent.
* There should be a single space after `{{` and before `}}`.

## Configuration

* Docker images should be configurable. Image tags should use stable versions.

```yaml
image:
  repository: myapp
  tag: 1.2.3
  pullPolicy: IfNotPresent
```

* The use of the `default` function should be avoided if possible in favor of defaults in `values.yaml`.
* It is usually best to not specify defaults for resources and to just provide sensible values that are commented out as a recommendation, especially when resources are rather high. This makes it easier to test charts on small clusters or Minikube. Setting resources should generally be a conscious choice of the user.

## Persistence

* Persistence should be enabled by default
* PVCs should support specifying an existing claim
* Storage class should be empty by default so that the default storage class is used
* All options should be shown in README.md
* Example persistence section in values.yaml:

```yaml
persistence:
  enabled: true
  ## If defined, storageClassName: <storageClass>
  ## If set to "-", storageClassName: "", which disables dynamic provisioning
  ## If undefined (the default) or set to null, no storageClassName spec is
  ##   set, choosing the default provisioner.  (gp2 on AWS, standard on
  ##   GKE, AWS & OpenStack)
  ##
  storageClass: ""
  accessMode: ReadWriteOnce
  size: 10Gi
  # existingClaim: ""
```

* Example pod spec within a deployment:

```yaml
volumes:
  - name: data
  {{- if .Values.persistence.enabled }}
    persistentVolumeClaim:
      claimName: {{ .Values.persistence.existingClaim | default (include "myapp.fullname" .) }}
  {{- else }}
    emptyDir: {}
  {{- end -}}
```

* Example pvc.yaml:

```yaml
{{- if and .Values.persistence.enabled (not .Values.persistence.existingClaim) }}
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: {{ include "myapp.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "myapp.name" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
    helm.sh/chart: {{ include "myapp.chart" . }}
spec:
  accessModes:
    - {{ .Values.persistence.accessMode | quote }}
  resources:
    requests:
      storage: {{ .Values.persistence.size | quote }}
{{- if .Values.persistence.storageClass }}
{{- if (eq "-" .Values.persistence.storageClass) }}
  storageClassName: ""
{{- else }}
  storageClassName: "{{ .Values.persistence.storageClass }}"
{{- end }}
{{- end }}
{{- end }}
```

## AutoScaling / HorizontalPodAutoscaler

* Autoscaling should be disabled by default
* All options should be shown in README.md

* Example autoscaling section in values.yaml:

```yaml
autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 5
  targetCPUUtilizationPercentage: 50
  targetMemoryUtilizationPercentage: 50
```

* Example hpa.yaml:

```yaml
{{- if .Values.autoscaling.enabled }}
apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: {{ include "myapp.fullname" . }}
  labels:
    app.kubernetes.io/name: {{ include "myapp.name" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
    helm.sh/chart: {{ include "myapp.chart" . }}
    app.kubernetes.io/component: "{{ .Values.name }}"
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: {{ include "myapp.fullname" . }}
  minReplicas: {{ .Values.autoscaling.minReplicas }}
  maxReplicas: {{ .Values.autoscaling.maxReplicas }}
  metrics:
    - type: Resource
      resource:
        name: cpu
        targetAverageUtilization: {{ .Values.autoscaling.targetCPUUtilizationPercentage }}
    - type: Resource
      resource:
        name: memory
        targetAverageUtilization: {{ .Values.autoscaling.targetMemoryUtilizationPercentage }}
{{- end }}
```

## Ingress

* See the [Ingress resource documentation](https://kubernetes.io/docs/concepts/services-networking/ingress/) for a broader concept overview
* Ingress should be disabled by default
* Example ingress section in values.yaml:

```yaml
ingress:
  enabled: false
  annotations: {}
    # kubernetes.io/ingress.class: nginx
    # kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - chart-example.test
  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.test
```

* Example ingress.yaml:

```yaml
{{- if .Values.ingress.enabled -}}
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: {{ include "myapp.fullname" }}
  labels:
    app.kubernetes.io/name: {{ include "myapp.name" . }}
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
    helm.sh/chart: {{ include "myapp.chart" . }}
{{- with .Values.ingress.annotations }}
  annotations:
{{ toYaml . | indent 4 }}
{{- end }}
spec:
{{- if .Values.ingress.tls }}
  tls:
  {{- range .Values.ingress.tls }}
    - hosts:
      {{- range .hosts }}
        - {{ . | quote }}
      {{- end }}
      secretName: {{ .secretName }}
  {{- end }}
{{- end }}
  rules:
  {{- range .Values.ingress.hosts }}
    - host: {{ . | quote }}
      http:
        paths:
          - path: {{ .Values.ingress.path }}
            backend:
              serviceName: {{ include "myapp.fullname" }}
              servicePort: http
  {{- end }}
{{- end }}
```

* Example prepend logic for getting an application URL in NOTES.txt:

```
{{- if .Values.ingress.enabled }}
{{- range .Values.ingress.hosts }}
  http{{ if $.Values.ingress.tls }}s{{ end }}://{{ . }}{{ $.Values.ingress.path }}
{{- end }}
```

## Documentation

`README.md` and `NOTES.txt` are mandatory. `README.md` should contain a table listing all configuration options. `NOTES.txt` should provide accurate and useful information how the chart can be used/accessed.

## Compatibility

We officially support compatibility with the current and the previous minor version of Kubernetes. Generated resources should use the latest possible API versions compatible with these versions. For extended backwards compatibility conditional logic based on capabilities may be used (see [built-in objects](https://github.com/helm/helm/blob/master/docs/chart_template_guide/builtin_objects.md)).

## Kubernetes Native Workloads

While reviewing Charts that contain workloads such as [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/), [StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/), [DaemonSets](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/) and [Jobs](https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/) the below points should be considered.  These are to be seen as best practices rather than strict enforcement.

1. Any workload that are stateless and long running (servers) in nature are to be created as Deployments.  Deployments in turn create ReplicaSets.
2. Unless there is a compelling reason, ReplicaSets or ReplicationControllers should be avoided as workload types.
3. Workloads that are stateful in nature such as databases, key-value stores, message queues, in-memory caches are to be created as StatefulSets
4. It is recommended that Deployments and StatefulSets configure their workloads with a [Pod Disruption Budget](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/) for high availability.
5. For workloads such as databases, KV stores, etc., that replicate data, it is recommended to configure interpod anti-affinity.
6. It is recommended to have a default workload update strategy configured that is suitable for this chart.
7. Batch workloads are to be created using Jobs.
8. It is best to always create workloads with the latest supported [api version](https://v1-8.docs.kubernetes.io/docs/api-reference/v1.8/) as older version are either deprecated or soon to be deprecated.
9. It is generally not advisable to provide hard [resource limits](https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/#resource-requests-and-limits-of-pod-and-container) to workloads and leave it configurable unless the workload requires such quantity bare minimum to function.
10. As much as possible complex pre-app setups are configured using [init containers](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).

More [configuration](https://kubernetes.io/docs/concepts/configuration/overview/) best practices.


text:
<?xml version="1.0" encoding="utf-8" ?>
<root>
  <server name="红泥巴.数字平台中心" type="dp2library" url="http://123.103.13.236/dp2library" userName="public"/>
  <server name="当前服务器" type="dp2library" url="." userName=".">
    <database name="中文图书" isTarget="yes" access="" entityAccess="append,overwrite"/>
    <database name="临时编目库" isTarget="yes" access="append,overwrite" entityAccess="append,overwrite"/>
  </server>
  <server name="亚马逊中国" type="amazon" url="webservices.amazon.cn"/>
</root>


text:
@interface BCOfflinePayResp : BCBaseResp

@property (nonatomic, retain) NSString *codeurl;
@property (nonatomic, retain) BCOfflinePayReq *request;

@end


text:
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65a.c
Label Definition File: CWE121_Stack_Based_Buffer_Overflow__CWE193.label.xml
Template File: sources-sink-65a.tmpl.c
*/
/*
 * @description
 * CWE: 121 Stack Based Buffer Overflow
 * BadSource:  Point data to a buffer that does not have space for a NULL terminator
 * GoodSource: Point data to a buffer that includes space for a NULL terminator
 * Sinks: memmove
 *    BadSink : Copy string to data using memmove()
 * Flow Variant: 65 Data/control flow: data passed as an argument from one function to a function in a different source file called via a function pointer
 *
 * */

#include "std_testcase.h"

#ifndef _WIN32
#include <wchar.h>
#endif

/* MAINTENANCE NOTE: The length of this string should equal the 10 */
#define SRC_STRING L"AAAAAAAAAA"

#ifndef OMITBAD

/* bad function declaration */
void CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65b_badSink(wchar_t * data);

void CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65_bad()
{
    wchar_t * data;
    /* define a function pointer */
    void (*funcPtr) (wchar_t *) = CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65b_badSink;
    wchar_t * dataBadBuffer = (wchar_t *)ALLOCA((10)*sizeof(wchar_t));
    wchar_t * dataGoodBuffer = (wchar_t *)ALLOCA((10+1)*sizeof(wchar_t));
    /* FLAW: Set a pointer to a buffer that does not leave room for a NULL terminator when performing
     * string copies in the sinks  */
    data = dataBadBuffer;
    data[0] = L'\0'; /* null terminate */
    /* use the function pointer */
    funcPtr(data);
}

#endif /* OMITBAD */

#ifndef OMITGOOD

/* goodG2B uses the GoodSource with the BadSink */
void CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65b_goodG2BSink(wchar_t * data);

static void goodG2B()
{
    wchar_t * data;
    void (*funcPtr) (wchar_t *) = CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65b_goodG2BSink;
    wchar_t * dataBadBuffer = (wchar_t *)ALLOCA((10)*sizeof(wchar_t));
    wchar_t * dataGoodBuffer = (wchar_t *)ALLOCA((10+1)*sizeof(wchar_t));
    /* FIX: Set a pointer to a buffer that leaves room for a NULL terminator when performing
     * string copies in the sinks  */
    data = dataGoodBuffer;
    data[0] = L'\0'; /* null terminate */
    funcPtr(data);
}

void CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65_good()
{
    goodG2B();
}

#endif /* OMITGOOD */

/* Below is the main(). It is only used when building this testcase on
 * its own for testing or for building a binary to use in testing binary
 * analysis tools. It is not used when compiling all the testcases as one
 * application, which is how source code analysis tools are tested.
 */

#ifdef INCLUDEMAIN

int main(int argc, char * argv[])
{
    /* seed randomness */
    srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
    printLine("Calling good()...");
    CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65_good();
    printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
    printLine("Calling bad()...");
    CWE121_Stack_Based_Buffer_Overflow__CWE193_wchar_t_alloca_memmove_65_bad();
    printLine("Finished bad()");
#endif /* OMITBAD */
    return 0;
}

#endif


text:
<?xml version="1.0"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <artifactId>MJAVADOC-280-3</artifactId>
    <groupId>org.apache.maven.plugins.maven-javadoc-plugin.it</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>

  <artifactId>MJAVADOC-280-3-modA</artifactId>
  <name>MJAVADOC-280-3-modA</name>

  <build>
    <plugins>
      <plugin>
        <artifactId>maven-javadoc-plugin</artifactId>
        <configuration>
          <tags>
            <tag><name>m.foo</name><placement>optm</placement>Foo:</tag>
            <tag><name>author</name></tag>
            <tag><name>version</name></tag>
            <tag><name>m.bar</name><placement>tcmf</placement>Bar:</tag>
            <tag><name>see</name></tag>
          </tags>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>


text:
<title>fmemopen - Untitled</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Untitled">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Stdio.html#Stdio" title="Stdio">
<link rel="prev" href="fileno.html#fileno" title="fileno">
<link rel="next" href="fopen.html#fopen" title="fopen">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<meta http-equiv="Content-Style-Type" content="text/css">

Next: fopen,
Previous: fileno,
Up: Stdio

4.16 fmemopen—open a stream around a fixed-length string

Synopsis

     #include <stdio.h>
     FILE *fmemopen(void *restrict <var>buf</var>, size_t <var>size</var>,
         const char *restrict <var>mode</var>);

Description

fmemopen creates a seekable FILE stream that wraps a
fixed-length buffer of <var>size</var> bytes starting at <var>buf</var>.  The stream
is opened with <var>mode</var> treated as in fopen, where append mode
starts writing at the first NUL byte.  If <var>buf</var> is NULL, then
<var>size</var> bytes are automatically provided as if by malloc, with
the initial size of 0, and <var>mode</var> must contain + so that data
can be read after it is written.

The stream maintains a current position, which moves according to
bytes read or written, and which can be one past the end of the array.
The stream also maintains a current file size, which is never greater
than <var>size</var>.  If <var>mode</var> starts with r, the position starts at
0, and file size starts at <var>size</var> if <var>buf</var> was provided.  If
<var>mode</var> starts with w, the position and file size start at 0,
and if <var>buf</var> was provided, the first byte is set to NUL.  If
<var>mode</var> starts with a, the position and file size start at the
location of the first NUL byte, or else <var>size</var> if <var>buf</var> was
provided.

When reading, NUL bytes have no significance, and reads cannot exceed
the current file size.  When writing, the file size can increase up to
<var>size</var> as needed, and NUL bytes may be embedded in the stream (see
open_memstream for an alternative that automatically enlarges the
buffer).  When the stream is flushed or closed after a write that
changed the file size, a NUL byte is written at the current position
if there is still room; if the stream is not also open for reading, a
NUL byte is additionally written at the last byte of <var>buf</var> when the
stream has exceeded <var>size</var>, so that a write-only <var>buf</var> is always
NUL-terminated when the stream is flushed or closed (and the initial
<var>size</var> should take this into account).  It is not possible to seek
outside the bounds of <var>size</var>.  A NUL byte written during a flush is
restored to its previous value when seeking elsewhere in the string.

Returns

The return value is an open FILE pointer on success.  On error,
NULL is returned, and errno will be set to EINVAL if <var>size</var>
is zero or <var>mode</var> is invalid, ENOMEM if <var>buf</var> was NULL and memory
could not be allocated, or EMFILE if too many streams are already
open.

Portability

This function is being added to POSIX 200x, but is not in POSIX 2001.

Supporting OS subroutines required: sbrk.


text:
"use strict";

var transform = require("../lib/6to5/transformation/transform");
var File      = require("../lib/6to5/file");
var util      = require("../lib/6to5/util");
var fs        = require("fs");
var t         = require("../lib/6to5/types");
var _         = require("lodash");

var relative = function (filename) {
  return __dirname + "/6to5-runtime/" + filename;
};

var writeFile = function (filename, content) {
  filename = relative(filename);
  console.log(filename);
  fs.writeFileSync(filename, content);
};

var readFile = function (filename) {
  return fs.readFileSync(require.resolve(filename), "utf8");
};

var updatePackage = function () {
  var pkgLoc = relative("package.json");
  var pkg    = require(pkgLoc);

  var mainPkg = require("../package.json");
  pkg.version = mainPkg.version;

  writeFile("package.json", JSON.stringify(pkg, null, 2));
};

var buildHelpers = function () {
  var body = [];
  var tree = t.program(body);

  _.each(File.helpers, function (name) {
    var key = t.identifier(t.toIdentifier(name));
    body.push(t.expressionStatement(
      t.assignmentExpression("=", t.memberExpression(t.identifier("exports"), key), util.template(name))
    ));
  });

  return transform.fromAst(tree, null, {
    optional: ["selfContained"]
  }).code;
};

writeFile("helpers.js", buildHelpers());
writeFile("core-js.js", readFile("core-js/library"));
writeFile("regenerator/index.js", readFile("regenerator-6to5/runtime-module"));
writeFile("regenerator/runtime.js", readFile("regenerator-6to5/runtime"));
updatePackage();