SUBROUTINE CDEDGE (
*
*  inputs
*
     :                  EDGECT, DEDGE, COUNT, DCOUNT, FLAG, X, Y,
     :                  OKVAL, HITVAL, DIMMAX, HPT, VPT,
*
*  output
*
     :                  XEDGE, YEDGE, DX, DY, NEDGE, STATUS)
*
*  Module number:
*
*  Module name:
*
*  Keyphrase:
*  ----------
*  delineate the contour which has the specified count.
*
*  Description:
*  ------------
*
*  FORTRAN name: CDEDGE.FOR
*
*  Keywords of accessed files and tables:
*  --------------------------------------
*  Name                         I/O     Description / Comments
*
*       None
*
*  Subroutines Called:
*  -------------------
*  CDBS:
*       None
*  SDAS:
*       UMSPUT
*  Others:
*       None
*
*  History:
*  --------
*  Version      Date        Author          Description
*     1       01-20-87     J.-C. HSU        design and coding
*     2       10-20-87     J.-C. HSU        F77 SDAS
*-------------------------------------------------------------------------------
*
*== input:
*                                       --number of columns and rows of the
*                                       --area scan
        INTEGER         HPT, VPT,
*                                       --dimension of COUNT, FLAG, X, and Y
*                                       --as declared in the calling routine
     :                  DIMMAX
*                                       --observed (average) number of counts,
*                                       --its standard deviation, its flag and
*                                       --its coordinates of each
*                                       --point of the scan
        REAL            COUNT(DIMMAX, DIMMAX), DCOUNT(DIMMAX, DIMMAX),
     :                  FLAG(DIMMAX, DIMMAX),
     :                  X(DIMMAX, DIMMAX), Y(DIMMAX, DIMMAX),
*                                       --specified edge count and its
*                                       --standard error
     :                  EDGECT, DEDGE,
*                                       --mask value of good data points
     :                  OKVAL,
*                                       --mask value of particle events
     :                  HITVAL
*
*== output
*                                       --edge coordinates and their
*                                       --standard error
        REAL            XEDGE(1), YEDGE(1), DX(1), DY(1)
*                                       --number of edge points
        INTEGER         NEDGE,
*                                       --error status
     :                  STATUS
*
*== local:
*                                       --status and loop indices
        INTEGER         I, J
*                                       --dummmies
        REAL            I2I1, II1, II2, X2X1, I1, I2, DI1, DI2, Y2Y1
*=========================begin hsp.inc=========================================
*                                       --status return code
        INTEGER         OK, ERRNUM(20)
        INTEGER         DEST, PRIO
        DATA OK /0/
        DATA ERRNUM /701, 702, 703, 704, 705, 706, 707, 708, 709, 710,
     :               711, 712, 713, 714, 715, 716, 717, 718, 719, 720/
*                                       --message destination and priority
        DATA DEST, PRIO /1, 0/
*=========================end hsp.inc===========================================
*------------------------------------------------------------------------------
*
*  initialize
*
        NEDGE = 0
*
*  look for edge point in the horizontal direction
*
        DO 20 I = 1, VPT
            DO 10 J = 1, HPT - 1
                IF (FLAG(I, J) .NE. HITVAL .AND.
     :                  FLAG(I, J+1) .NE. HITVAL) THEN
*
* ascending point
*
                    IF ((COUNT(I, J) .LE. EDGECT .AND.
     :                          COUNT(I, J+1) .GT. EDGECT) .OR.
*
*  decending point
*
     :                          (COUNT(I, J) .GT. EDGECT .AND.
     :                          COUNT(I, J+1) .LE. EDGECT)) THEN
                        I1 = COUNT(I, J)
                        I2 = COUNT(I, J+1)
                        DI1 = DCOUNT(I, J)
                        DI2 = DCOUNT(I, J+1)
                        II1 = EDGECT - I1
                        II2 = EDGECT - I2
                        X2X1 = X(I, J+1) - X(I, J)
                        I2I1 = I2 - I1
                        NEDGE = NEDGE + 1
*
                        XEDGE(NEDGE) = X(I, J) + II1 * X2X1 / I2I1
                        DX(NEDGE) = ABS(X2X1) * SQRT((DI1 * II2) ** 2 +
     :                          (DI2 * II1) ** 2)
     :                          / (I2I1 ** 2)
*
                        YEDGE(NEDGE) = Y(I, J)
                        DY(NEDGE) = 0.
                    END IF
                END IF
   10       CONTINUE
   20   CONTINUE
*
*  look for edge point in the vertical direction
*
        DO 40 J = 1, HPT
            DO 30 I = 1, VPT - 1
                IF (FLAG(I, J) .NE. HITVAL .AND.
     :                  FLAG(I+1, J) .NE. HITVAL) THEN
*
* ascending point
*
                    IF ((COUNT(I, J) .LE. EDGECT .AND.
     :                          COUNT(I+1, J) .GT. EDGECT) .OR.
*
*  decending point
*
     :                          (COUNT(I, J) .GT. EDGECT .AND.
     :                          COUNT(I+1, J) .LE. EDGECT)) THEN
                        I1 = COUNT(I, J)
                        I2 = COUNT(I+1, J)
                        DI1 = DCOUNT(I, J)
                        DI2 = DCOUNT(I+1, J)
                        II1 = EDGECT - I1
                        II2 = EDGECT - I2
                        Y2Y1 = Y(I+1, J) - Y(I, J)
                        I2I1 = I2 - I1
                        NEDGE = NEDGE + 1
*
                        YEDGE(NEDGE) = Y(I, J) + II1 * Y2Y1 / I2I1
                        DY(NEDGE) = ABS(Y2Y1) * SQRT((DI1 * II2) ** 2 +
     :                          (DI2 * II1) ** 2 + (DEDGE * I2I1) ** 2)
     :                          / (I2I1 ** 2)
*
                        XEDGE(NEDGE) = X(I, J)
                        DX(NEDGE) = 0.
                    END IF
                END IF
   30       CONTINUE
   40   CONTINUE
*
        STATUS = OK
        GO TO 1000
*
 1000   RETURN
        END