MODULE PZTestSmooth EXPORTS Main;

(* Tests PZSmooth *)
(* Last edited on 1999-08-15 12:55:55 by hcgl *)

IMPORT  Fmt, ParseParams, Process, FileRd, Wr, FileWr;
IMPORT  OSError, Thread, Stdio, LR3;
IMPORT PZSmooth, PZLR3Chain, PZLRChain;

FROM Stdio IMPORT stderr;
FROM PZTypes IMPORT LONG, LONGS, NAT;
 
<* FATAL Wr.Failure, Thread.Alerted, OSError.E *>

TYPE
  MismatchOptions = PZMismatch.Options;
  Options = RECORD
      inName: TEXT;   (* Input float chain file (without ".flc"). *)
      outName: TEXT;  (* Output float/curv chain file name (without ".flc"). *)
      sigma: LONG;    (* Parameter of Gaussian filter  *)
      nSamples: NAT;  (* Number of filtered samples    *)           
    END;
    
PROCEDURE Main() =
  BEGIN
    WITH
      o = GetOptions(),
      rp = PZLR3Chain.Read(FileRd.Open(o.inName & ".flc")),
      p = rp.c^,
      pCmt = rp.cmt,
      np = NUMBER(p),
      tpStart = 17.0d0,
      tp = ComputeNaturalTimes(p, tStart := tpStart)^,
      tpPeriod = tp[n-1] - tpStart,
      u = NEW(REF PZLR3Chain.T, o.nSamples)^,
      tuStart = 23.0d0,
      tu = ComputeSampleTimes(o.nSamples, tStart := tuStart, tPeriod := tpPeriod)^
    DO
      WriteLabels(o.inName, ".lbl", 0.010d0, pCmt & "\n original curve \n", tp, tpPeriod);
      PZSmooth.Polygonal(o.sigma, p, tp, tpPeriod, tuStart, u);
      Wr.PutText(stderr, o.outName & ".flc" & "\n"); 
      WritePolygonal(o.outName, ".flc", 0.010d0, pCmt & "\n smoothed curve \n", u);
      WriteLabels(o.outName, ".lbl", 0.010d0, pCmt & "\n smoothed curve \n", tu, tpPeriod);
    END
  END Main;
 
PROCEDURE ComputeNaturalTimes(READONLY p: PZLR3Chain.T; tStart: LONG): REF LONGS =
  VAR d: LONG := tStart;
      ia: NAT;
  BEGIN
    WITH
      n = NUMBER(p),
      rs = NEW(REF LONGS, n), s = rs^
    DO
      ia := n-1;
      FOR i := 0 TO n-1 DO
        d := d + LR3.Dist(p[ia], p[i]);
        s[i] := d; ia := i;
      END;
      RETURN rs
    END
  END ComputeNaturalTimes;

PROCEDURE ComputeSampleTimes(nSamples: NAT; tStart: LONG; tPeriod: LONG): REF LONGS =
  BEGIN
    WITH
      rs = NEW(REF LONGS, nSamples), s = rs^
    DO
      FOR i := 0 TO nSamples-1 DO
        s[i] := tStart + tPeriod*FLOAT(i, LONG)/FLOAT(nSamples, LONG)
      END;
      RETURN rs
    END
  END ComputeSampleTimes;
 
PROCEDURE GetOptions(): Options =
  VAR o: Options;
  BEGIN
    WITH
      pp = NEW(ParseParams.T).init(stderr)
    DO
      TRY
        pp.getKeyword("-inName");
        o.inName := pp.getNext();
        
        pp.getKeyword("-outName");
        o.outName := pp.getNext();
        
        pp.getKeyword("-sigma");
        o.sigma := pp.getNextLongReal();
        
        pp.getKeyword("-nSamples");
        o.nSamples := pp.getNextInt();
      EXCEPT                                                            
      | ParseParams.Error =>                                              
          Wr.PutText(stderr, "Usage: PZTestSmooth \\\n");
          Wr.PutText(stderr, "  -inName NAME \\\n");
          Wr.PutText(stderr, "  -outName NAME  \\\n");
          Wr.PutText(stderr, "  -sigma NUM \\\n");
          Wr.PutText(stderr, "  -nSamples NUM \\\n");
        Process.Exit(1);
      END;
    END;
    RETURN o
  END GetOptions;
 
PROCEDURE WritePolygonal(
    name: TEXT;
    ext : TEXT; 
    unit: LONG;
    pCmt: TEXT;
    READONLY c: PZLR3Chain.T;
  ) = 
  BEGIN
    WITH fileName = name &  ext DO
      Wr.PutText(stderr, "writing file " & fileName & " ...\n");
      PZLR3Chain.Write(FileWr.Open(fileName), pCmt, c, unit)
    END
  END WritePolygonal;

PROCEDURE WriteLabels(
    name: TEXT;
    ext : TEXT; 
    unit: LONG;
    pCmt: TEXT;
    READONLY r: PZLRChain.T;
    rPeriod: LONG;
  ) = 
  BEGIN
    WITH fileName = name &  ext DO
      Wr.PutText(stderr, "writing file " & fileName & " ...\n");
      PZLRChain.Write(FileWr.Open(fileName), pCmt, r, stride := rPeriod, unit := unit)
    END
  END WriteLabels;

PROCEDURE FLR(x: LONG; w, p: NAT): TEXT =
  BEGIN
    RETURN Fmt.Pad(Fmt.LongReal(x, Fmt.Style.Fix, prec := p), w)
  END FLR;
   

BEGIN
  Main()
END PZTestSmooth.