Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/high-to-mid/coord-space-transform.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/high-to-mid/coord-space-transform.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3731, Thu Apr 7 19:25:15 2016 UTC revision 3732, Thu Apr 7 20:56:16 2016 UTC
# Line 17  Line 17 
17     * assignments that computes the world-space to -image-space transformation.     * assignments that computes the world-space to -image-space transformation.
18     *)     *)
19      val worldToImage : {      val worldToImage : {
20                avail : AvailRHS.avail,
21              info : ImageInfo.info,      (* the image info for the image *)              info : ImageInfo.info,      (* the image info for the image *)
22              img : MidIR.var,            (* the variable bound to the image *)              img : MidIR.var,            (* the variable bound to the image *)
23              pos : MidIR.var             (* the variable bound to the world-space position *)              pos : MidIR.var             (* the variable bound to the world-space position *)
24            } -> MidIR.var * MidIR.var * MidIR.assign list            } -> MidIR.var * MidIR.var
25    
26      val worldToIndex : {      val worldToIndex : {
27                avail : AvailRHS.avail,
28              info : ImageInfo.info,      (* the image info for the image *)              info : ImageInfo.info,      (* the image info for the image *)
29              img : MidIR.var,            (* the variable bound to the image *)              img : MidIR.var,            (* the variable bound to the image *)
30              pos : MidIR.var             (* the variable bound to the world-space position *)              pos : MidIR.var             (* the variable bound to the world-space position *)
31            } -> MidIR.var list * MidIR.var * MidIR.assign list            } -> MidIR.var * MidIR.var * MidIR.var
32    
33      val imageToWorld : Ein.tensor_id * int * Ein.mu list * Ein.tensor_id      val imageToWorld : Ein.tensor_id * int * Ein.mu list * Ein.tensor_id
34            -> (Ein.mu list * Ein.sumrange list * Ein.ein_exp list)            -> (Ein.mu list * Ein.sumrange list * Ein.ein_exp list)
# Line 54  Line 56 
56          ->mid-il var * mid-il var *code          ->mid-il var * mid-il var *code
57      *transform image-space position x to world space position      *transform image-space position x to world space position
58      *)      *)
59      fun worldToImage {info, img, pos} = let      fun worldToImage {avail, info, img, pos} = let
60            val dim = ImageInfo.dim info            val dim = ImageInfo.dim info
61            val (_, fty, pty) = getTys dim            val (_, fty, pty) = getTys dim
62            val mty = Ty.TensorTy pty            val mty = Ty.TensorTy pty
63            val rty = Ty.TensorTy fty            val rty = Ty.TensorTy fty
64            val M = V.new ("M", mty)   (*transform dim by dim?*)            val M = Avail.addAssign (avail, "M", mty, IR.OP(Op.Transform info, [img]))
65            val T = V.new ("T", rty)            val T = Avail.addAssign (avail, "T", rty, IR.OP(Op.Translate info, [img]))
           val x = V.new ("x", rty)            (*Image-Space position*)  
           val x0 = V.new ("x0", rty)  
66            val (mulOp, addOp) = if (dim = 1)            val (mulOp, addOp) = if (dim = 1)
67                  then (Mk.mulRR, Mk.addRR)                  then (Mk.mulRR, Mk.addRR)
68                  else (Mk.innerTT([dim, dim], [dim]), Mk.addTT[dim])                  else (Mk.innerTT([dim, dim], [dim]), Mk.addTT[dim])
69            val code = [            val x0 = Avail.addAssign (avail, "x0", rty, IR.OP(mulOp, [M, pos]))            (*Image-Space position*)
70                    assign (M, Op.Transform info, [img]),            val x = Avail.addAssign (avail, "x", rty, IR.OP(addOp, [x0, T]))
                   assign (T, Op.Translate info, [img]),  
                   assignEin (x0, mulOp, [M, pos]),      (*xo=MX*)  
                   assignEin (x, addOp, [x0, T]) (*x=x0+T*)  
                 ]  
71            in            in
72              (M, x, code)              (M, x)
73            end            end
74    
75      (*transformToImgSpae:int*imginfo*mid-ilvar*mid-ilvar      (*transformToImgSpae:int*imginfo*mid-ilvar*mid-ilvar
76          -> mid_il var list * mid-il var* code          -> mid_il var list * mid-il var* code
77      *Create fractional, and integer position vectors      *Create fractional, and integer position vectors
78      *)      *)
79      fun worldToIndex (arg as {info, img, pos}) = let      fun worldToIndex (arg as {avail, info, img, pos}) = let
80            val dim = ImageInfo.dim info            val dim = ImageInfo.dim info
81            val (ity, fty, pty) = getTys dim            val (ity, fty, pty) = getTys dim
82            val mty = Ty.TensorTy  pty            val mty = Ty.TensorTy  pty
83            val rty = Ty.TensorTy fty            val rty = Ty.TensorTy fty
84            val f = V.new ("f", rty)              (* fractional *)            val (M, x) = worldToImage arg
85            val nd = V.new ("nd",  rty)           (* real position *)            val nd = Avail.addAssign (avail, "nd", rty, IR.OP(Op.Floor dim, [x]))         (* real position *)
86            val n = V.new ("n", ity)              (* integer position *)            val f = Avail.addAssign (avail, "f", rty, IR.OP(Mk.subTT fty, [x, nd]))       (* fractional *)
87            val (M, x, code1) = worldToImage arg            val n = Avail.addAssign (avail, "n", ity, IR.OP(Op.RealToInt dim, [nd]))      (* integer position *)
88            val code = [            val P = if (dim = 1)
89                    assign (nd, Op.Floor dim, [x]),       (*nd *)                  then M
90                    assignEin (f, Mk.subTT(fty),[x,nd]),  (*fractional*)                  else Avail.addAssign (avail, "P", mty, IR.OP(Mk.transposeT pty, [M]))
                   assign (n, Op.RealToInt dim, [nd])    (*real to Int*)  
                 ]  
           val (P, code) = if (dim = 1)  
                 then (M, code)  
                 else let  
                   val P = V.new ("P", mty)  
91                    in                    in
92                      (P, assignEin(P, Mk.transposeT pty, [M]) :: code)              (n, f, P)
                   end  
           in  
             ([n, f], P, code1 @ code)  
93            end            end
94    
95      (*transformToIndexSpace:int*int*mu list * param_id      (*transformToIndexSpace:int*int*mu list * param_id

Legend:
Removed from v.3731  
changed lines
  Added in v.3732

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0