MODULE PZTestSmooth EXPORTS Main;

(* Tests PZSmooth *)

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

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

TYPE
  LONG = LONGREAL;

  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  *)
      m : CARDINAL;         (* 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,
      n = NUMBER(p),
      len = ComputeLengths(p)^,
      t = SUBARRAY(len, 0, n),
      tPeriod = len[n],
      u = NEW(REF PZLR3Chain.T,o.m)^,
      v = NEW(REF PZLR3Chain.T,o.m)^,
      w = NEW(REF PZLR3Chain.T,o.m)^
    DO
      PZSmooth.Polygonal(o.sigma, p, t, tPeriod, 0.0d0, u, v, w);
      Wr.PutText(stderr, "PolygonAcc...\n"); 
      WritePolygonal(o.outName, ".flc", 0.010d0, pCmt & "\n smoothed curve \n", u);
      WritePolygonal(o.outName, ".flv", 0.010d0, pCmt & "\n velocity of smoothed curve\n", v);
      WritePolygonal(o.outName, ".fla", 0.001d0, pCmt & "\n acc. of smoothed curve\n", w);
    END
  END Main;
 
PROCEDURE ComputeLengths(READONLY p: PZLR3Chain.T): REF ARRAY OF LONG =
  VAR d: LONG := 0.0d0;
  BEGIN
    WITH
      n = NUMBER(p),
      rs = NEW(REF ARRAY OF LONG, n+1),
      s = rs^
    DO
      s[0] := 0.0d0;
      Wr.PutText(stderr, FLR(s[0],8,4) & " ");
      FOR i := 1 TO n-1 DO
        d := d + LR3.Dist(p[i], p[i-1]);
        s[i] := d;
        IF (i MOD 8) = 0  THEN Wr.PutText(stderr,"\n")  END;
        Wr.PutText(stderr, FLR(s[i],8,4) & " ");
      END;
      d := d + LR3.Dist(p[n-1], p[0]);
      s[n] := d;
      Wr.PutText(stderr, FLR(s[n],8,4));
      Wr.PutText(stderr,"\n");
      RETURN rs
    END
  END ComputeLengths;

 
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("-m");
        o.m := 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, "  -m 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 FLR(x: LONGREAL; w, p: CARDINAL): TEXT =
  BEGIN
    RETURN Fmt.Pad(Fmt.LongReal(x, Fmt.Style.Fix, prec := p), w)
  END FLR;
   

BEGIN
  Main()
END PZTestSmooth.