ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/bsdf_m.c
(Generate patch)

Comparing ray/src/common/bsdf_m.c (file contents):
Revision 3.1 by greg, Fri Feb 18 00:40:25 2011 UTC vs.
Revision 3.9 by greg, Fri Apr 8 18:13:48 2011 UTC

# Line 1 | Line 1
1 + #ifndef lint
2 + static const char RCSid[] = "$Id$";
3 + #endif
4   /*
5   *  bsdf_m.c
6   *  
# Line 8 | Line 11
11   *
12   */
13  
14 < #include <stdio.h>
14 > #include "rtio.h"
15   #include <stdlib.h>
16   #include <math.h>
14 – #include <strings.h>
17   #include <ctype.h>
18   #include "ezxml.h"
19   #include "bsdf.h"
20   #include "bsdf_m.h"
21  
20 – #ifndef FTINY
21 – #define FTINY           1e-6
22 – #endif
23 –
22   /* Function return codes */
23   #define RC_GOOD         1
24   #define RC_FAIL         0
# Line 88 | Line 86 | fequal(double a, double b)
86          return (a <= 1e-6) & (a >= -1e-6);
87   }
88  
89 < /* returns the name of the given tag */
89 > /* Returns the name of the given tag */
90   #ifdef ezxml_name
91   #undef ezxml_name
92   static char *
# Line 100 | Line 98 | ezxml_name(ezxml_t xml)
98   }
99   #endif
100  
101 < /* returns the given tag's character content or empty string if none */
101 > /* Returns the given tag's character content or empty string if none */
102   #ifdef ezxml_txt
103   #undef ezxml_txt
104   static char *
# Line 159 | Line 157 | SDnewMatrix(int ni, int no)
157   /* Free a BSDF matrix */
158   #define SDfreeMatrix            free
159  
160 < /* get vector for this angle basis index */
160 > /* get vector for this angle basis index (front exiting) */
161   static int
162 < ab_getvec(FVECT v, int ndx, double randX, void *p)
162 > fo_getvec(FVECT v, double ndxr, void *p)
163   {
164 <        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
164 >        ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
165 >        int             ndx = (int)ndxr;
166 >        double          randX = ndxr - ndx;
167          double          rx[2];
168          int             li;
169          double          pol, azi, d;
170          
171 <        if ((ndx < 0) | (ndx >= ab->nangles))
171 >        if ((ndxr < 0) | (ndx >= ab->nangles))
172                  return RC_FAIL;
173          for (li = 0; ndx >= ab->lat[li].nphis; li++)
174                  ndx -= ab->lat[li].nphis;
# Line 183 | Line 183 | ab_getvec(FVECT v, int ndx, double randX, void *p)
183          return RC_GOOD;
184   }
185  
186 < /* get index corresponding to the given vector */
186 > /* get index corresponding to the given vector (front exiting) */
187   static int
188 < ab_getndx(const FVECT v, void *p)
188 > fo_getndx(const FVECT v, void *p)
189   {
190 <        ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
190 >        ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
191          int     li, ndx;
192          double  pol, azi, d;
193  
# Line 212 | Line 212 | ab_getndx(const FVECT v, void *p)
212   /* compute square of real value */
213   static double sq(double x) { return x*x; }
214  
215 < /* get projected solid angle for this angle basis index */
215 > /* get projected solid angle for this angle basis index (universal) */
216   static double
217 < ab_getohm(int ndx, void *p)
217 > io_getohm(int ndx, void *p)
218   {
219          static int      last_li = -1;
220          static double   last_ohm;
# Line 237 | Line 237 | ab_getohm(int ndx, void *p)
237                                  (double)ab->lat[li].nphis;
238   }
239  
240 < /* get reverse vector for this angle basis index */
240 > /* get vector for this angle basis index (back incident) */
241   static int
242 < ab_getvecR(FVECT v, int ndx, double randX, void *p)
242 > bi_getvec(FVECT v, double ndxr, void *p)
243   {
244 <        int     na = (*(ANGLE_BASIS *)p).nangles;
245 <
246 <        if (!ab_getvec(v, ndx, randX, p))
244 >        if (!fo_getvec(v, ndxr, p))
245                  return RC_FAIL;
246  
247          v[0] = -v[0];
# Line 253 | Line 251 | ab_getvecR(FVECT v, int ndx, double randX, void *p)
251          return RC_GOOD;
252   }
253  
254 < /* get index corresponding to the reverse vector */
254 > /* get index corresponding to the vector (back incident) */
255   static int
256 < ab_getndxR(const FVECT v, void *p)
256 > bi_getndx(const FVECT v, void *p)
257   {
258          FVECT  v2;
259          
# Line 263 | Line 261 | ab_getndxR(const FVECT v, void *p)
261          v2[1] = -v[1];
262          v2[2] = -v[2];
263  
264 <        return ab_getndx(v2, p);
264 >        return fo_getndx(v2, p);
265   }
266  
267 + /* get vector for this angle basis index (back exiting) */
268 + static int
269 + bo_getvec(FVECT v, double ndxr, void *p)
270 + {
271 +        if (!fo_getvec(v, ndxr, p))
272 +                return RC_FAIL;
273 +
274 +        v[2] = -v[2];
275 +
276 +        return RC_GOOD;
277 + }
278 +
279 + /* get index corresponding to the vector (back exiting) */
280 + static int
281 + bo_getndx(const FVECT v, void *p)
282 + {
283 +        FVECT  v2;
284 +        
285 +        v2[0] = v[0];
286 +        v2[1] = v[1];
287 +        v2[2] = -v[2];
288 +
289 +        return fo_getndx(v2, p);
290 + }
291 +
292 + /* get vector for this angle basis index (front incident) */
293 + static int
294 + fi_getvec(FVECT v, double ndxr, void *p)
295 + {
296 +        if (!fo_getvec(v, ndxr, p))
297 +                return RC_FAIL;
298 +
299 +        v[0] = -v[0];
300 +        v[1] = -v[1];
301 +
302 +        return RC_GOOD;
303 + }
304 +
305 + /* get index corresponding to the vector (front incident) */
306 + static int
307 + fi_getndx(const FVECT v, void *p)
308 + {
309 +        FVECT  v2;
310 +        
311 +        v2[0] = -v[0];
312 +        v2[1] = -v[1];
313 +        v2[2] = v[2];
314 +
315 +        return fo_getndx(v2, p);
316 + }
317 +
318   /* load custom BSDF angle basis */
319   static int
320   load_angle_basis(ezxml_t wab)
# Line 348 | Line 397 | get_extrema(SDSpectralDF *df)
397          }
398          free(ohma);
399                                          /* need incoming solid angles, too? */
400 <        if (dp->ninc < dp->nout || dp->ib_ohm != dp->ob_ohm ||
352 <                                dp->ib_priv != dp->ob_priv) {
400 >        if ((dp->ib_ohm != dp->ob_ohm) | (dp->ib_priv != dp->ob_priv)) {
401                  double  ohm;
402                  for (i = dp->ninc; i--; )
403                          if ((ohm = mBSDF_incohm(dp,i)) < df->minProjSA)
# Line 358 | Line 406 | get_extrema(SDSpectralDF *df)
406          return (df->maxHemi <= 1.01);
407   }
408  
361 – /* skip integer in string */
362 – static char *
363 – i_skip(char  *s)
364 – {
365 –        while (isspace(*s))
366 –                s++;
367 –        if (*s == '-' || *s == '+')
368 –                s++;
369 –        if (!isdigit(*s))
370 –                return(NULL);
371 –        do
372 –                s++;
373 –        while (isdigit(*s));
374 –        return(s);
375 – }
376 –
377 – /* skip float in string */
378 – static char *
379 – f_skip(char  *s)
380 – {
381 –        register char  *cp;
382 –
383 –        while (isspace(*s))
384 –                s++;
385 –        if (*s == '-' || *s == '+')
386 –                s++;
387 –        cp = s;
388 –        while (isdigit(*cp))
389 –                cp++;
390 –        if (*cp == '.') {
391 –                cp++; s++;
392 –                while (isdigit(*cp))
393 –                        cp++;
394 –        }
395 –        if (cp == s)
396 –                return(NULL);
397 –        if (*cp == 'e' || *cp == 'E')
398 –                return(i_skip(cp+1));
399 –        return(cp);
400 – }
401 –
409   /* load BSDF distribution for this wavelength */
410   static int
411   load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
412   {
406 –        char            *cbasis = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
407 –        char            *rbasis = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
413          SDSpectralDF    *df;
414          SDMat           *dp;
415          char            *sdata;
416 +        int             tfront;
417          int             inbi, outbi;
418          int             i;
413 –
414 –        if ((!cbasis || !*cbasis) | (!rbasis || !*rbasis)) {
415 –                sprintf(SDerrorDetail, "Missing column/row basis for BSDF '%s'",
416 –                                sd->name);
417 –                return RC_FORMERR;
418 –        }
419                                          /* allocate BSDF component */
420          sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
421 <        if (!strcasecmp(sdata, "Transmission Front")) {
421 >        /*
422 >         * Remember that front and back are reversed from WINDOW 6 orientations
423 >         * Favor their "Front" (incoming light) since that's more often valid
424 >         */
425 >        tfront = !strcasecmp(sdata, "Transmission Back");
426 >        if (!strcasecmp(sdata, "Transmission Front") ||
427 >                        tfront & (sd->tf == NULL)) {
428                  if (sd->tf != NULL)
429                          SDfreeSpectralDF(sd->tf);
430                  if ((sd->tf = SDnewSpectralDF(1)) == NULL)
431                          return RC_MEMERR;
432                  df = sd->tf;
433          } else if (!strcasecmp(sdata, "Reflection Front")) {
434 <                if (sd->rf != NULL)
429 <                        SDfreeSpectralDF(sd->rf);
430 <                if ((sd->rf = SDnewSpectralDF(1)) == NULL)
431 <                        return RC_MEMERR;
432 <                df = sd->rf;
433 <        } else if (!strcasecmp(sdata, "Reflection Back")) {
434 <                if (sd->rb != NULL)
434 >                if (sd->rb != NULL)     /* note back-front reversal */
435                          SDfreeSpectralDF(sd->rb);
436                  if ((sd->rb = SDnewSpectralDF(1)) == NULL)
437                          return RC_MEMERR;
438                  df = sd->rb;
439 +        } else if (!strcasecmp(sdata, "Reflection Back")) {
440 +                if (sd->rf != NULL)     /* note front-back reversal */
441 +                        SDfreeSpectralDF(sd->rf);
442 +                if ((sd->rf = SDnewSpectralDF(1)) == NULL)
443 +                        return RC_MEMERR;
444 +                df = sd->rf;
445          } else
446                  return RC_FAIL;
447 +        /* XXX should also check "ScatteringDataType" for consistency? */
448                                          /* get angle bases */
449          sdata = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
450          if (!sdata || !*sdata) {
# Line 446 | Line 453 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
453                  return RC_FORMERR;
454          }
455          for (inbi = nabases; inbi--; )
456 <                if (!strcasecmp(cbasis, abase_list[inbi].name))
456 >                if (!strcasecmp(sdata, abase_list[inbi].name))
457                          break;
458          if (inbi < 0) {
459 <                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'",
453 <                                cbasis);
459 >                sprintf(SDerrorDetail, "Undefined ColumnAngleBasis '%s'", sdata);
460                  return RC_FORMERR;
461          }
462          sdata = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
# Line 460 | Line 466 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
466                  return RC_FORMERR;
467          }
468          for (outbi = nabases; outbi--; )
469 <                if (!strcasecmp(rbasis, abase_list[outbi].name))
469 >                if (!strcasecmp(sdata, abase_list[outbi].name))
470                          break;
471          if (outbi < 0) {
472 <                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", cbasis);
472 >                sprintf(SDerrorDetail, "Undefined RowAngleBasis '%s'", sdata);
473                  return RC_FORMERR;
474          }
475                                          /* allocate BSDF matrix */
476          dp = SDnewMatrix(abase_list[inbi].nangles, abase_list[outbi].nangles);
477          if (dp == NULL)
478                  return RC_MEMERR;
479 <        dp->ib_priv = (void *)&abase_list[inbi];
480 <        dp->ob_priv = (void *)&abase_list[outbi];
479 >        dp->ib_priv = &abase_list[inbi];
480 >        dp->ob_priv = &abase_list[outbi];
481          if (df == sd->tf) {
482 <                dp->ib_vec = ab_getvecR;
483 <                dp->ib_ndx = ab_getndxR;
484 <                dp->ob_vec = ab_getvec;
485 <                dp->ob_ndx = ab_getndx;
482 >                if (tfront) {
483 >                        dp->ib_vec = &fi_getvec;
484 >                        dp->ib_ndx = &fi_getndx;
485 >                        dp->ob_vec = &bo_getvec;
486 >                        dp->ob_ndx = &bo_getndx;
487 >                } else {
488 >                        dp->ib_vec = &bi_getvec;
489 >                        dp->ib_ndx = &bi_getndx;
490 >                        dp->ob_vec = &fo_getvec;
491 >                        dp->ob_ndx = &fo_getndx;
492 >                }
493          } else if (df == sd->rf) {
494 <                dp->ib_vec = ab_getvec;
495 <                dp->ib_ndx = ab_getndx;
496 <                dp->ob_vec = ab_getvec;
497 <                dp->ob_ndx = ab_getndx;
494 >                dp->ib_vec = &fi_getvec;
495 >                dp->ib_ndx = &fi_getndx;
496 >                dp->ob_vec = &fo_getvec;
497 >                dp->ob_ndx = &fo_getndx;
498          } else /* df == sd->rb */ {
499 <                dp->ib_vec = ab_getvecR;
500 <                dp->ib_ndx = ab_getndxR;
501 <                dp->ob_vec = ab_getvecR;
502 <                dp->ob_ndx = ab_getndxR;
499 >                dp->ib_vec = &bi_getvec;
500 >                dp->ib_ndx = &bi_getndx;
501 >                dp->ob_vec = &bo_getvec;
502 >                dp->ob_ndx = &bo_getndx;
503          }
504 <        dp->ib_ohm = ab_getohm;
505 <        dp->ob_ohm = ab_getohm;
504 >        dp->ib_ohm = &io_getohm;
505 >        dp->ob_ohm = &io_getohm;
506          df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
507          df->comp[0].dist = dp;
508          df->comp[0].func = &SDhandleMtx;
# Line 501 | Line 514 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
514                  return RC_FORMERR;
515          }
516          for (i = 0; i < dp->ninc*dp->nout; i++) {
517 <                char  *sdnext = f_skip(sdata);
517 >                char  *sdnext = fskip(sdata);
518                  if (sdnext == NULL) {
519                          sprintf(SDerrorDetail,
520                                  "Bad/missing BSDF ScatteringData in '%s'",
# Line 558 | Line 571 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
571                  c_cmix(&dv->spec, dv->cieY, &dv->spec, ymin, &df->comp[n].cspec[0]);
572                  dv->cieY += ymin;
573          }
574 <        df->maxHemi -= dv->cieY;        /* correct minimum hemispherical */
575 <        dv->spec.clock++;               /* make sure everything is set */
574 >        df->maxHemi -= dv->cieY;        /* adjust minimum hemispherical */
575 >                                        /* make sure everything is set */
576          c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
577   }
578  
579   /* Load a BSDF matrix from an open XML file */
580   SDError
581 < SDloadMtx(SDData *sd, ezxml_t fl)
581 > SDloadMtx(SDData *sd, ezxml_t wtl)
582   {
583 <        ezxml_t                 wtl, wld, wdb;
583 >        ezxml_t                 wld, wdb;
584          int                     rowIn;
585          struct BSDF_data        *dp;
586          char                    *txt;
587          int                     rval;
588          
589 <        if (strcmp(ezxml_name(fl), "WindowElement")) {
589 >        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
590 >                        "DataDefinition"), "IncidentDataStructure"));
591 >        if (txt == NULL || !*txt) {
592                  sprintf(SDerrorDetail,
593 <                        "BSDF \"%s\": top level node not 'WindowElement'",
593 >                        "BSDF \"%s\": missing IncidentDataStructure",
594                                  sd->name);
595                  return SDEformat;
596          }
582 –        wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
583 –        txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
584 –                        "DataDefinition"), "IncidentDataStructure"));
597          if (!strcasecmp(txt, "Rows"))
598                  rowIn = 1;
599          else if (!strcasecmp(txt, "Columns"))
# Line 596 | Line 608 | SDloadMtx(SDData *sd, ezxml_t fl)
608          rval = load_angle_basis(ezxml_child(ezxml_child(wtl,
609                                  "DataDefinition"), "AngleBasis"));
610          if (rval < 0)
611 <                goto err_return;
611 >                return convert_errcode(rval);
612                                  /* load BSDF components */
613          for (wld = ezxml_child(wtl, "WavelengthData");
614                                  wld != NULL; wld = wld->next) {
# Line 606 | Line 618 | SDloadMtx(SDData *sd, ezxml_t fl)
618                  for (wdb = ezxml_child(wld, "WavelengthDataBlock");
619                                          wdb != NULL; wdb = wdb->next)
620                          if ((rval = load_bsdf_data(sd, wdb, rowIn)) < 0)
621 <                                goto err_return;
621 >                                return convert_errcode(rval);
622          }
623                                  /* separate diffuse components */
624          extract_diffuse(&sd->rLambFront, sd->rf);
# Line 614 | Line 626 | SDloadMtx(SDData *sd, ezxml_t fl)
626          extract_diffuse(&sd->tLamb, sd->tf);
627                                  /* return success */
628          return SDEnone;
617 – err_return:                     /* jump here on failure */
618 –        if (sd->rf != NULL) {
619 –                SDfreeSpectralDF(sd->rf);
620 –                sd->rf = NULL;
621 –        }
622 –        if (sd->rb != NULL) {
623 –                SDfreeSpectralDF(sd->rb);
624 –                sd->rb = NULL;
625 –        }
626 –        if (sd->tf != NULL) {
627 –                SDfreeSpectralDF(sd->tf);
628 –                sd->tf = NULL;
629 –        }
630 –        return convert_errcode(rval);
629   }
630  
631   /* Get Matrix BSDF value */
# Line 656 | Line 654 | static SDError
654   SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
655   {
656          const SDMat     *dp = (const SDMat *)dist;
657 <
658 <        if (!(qflags & SDqueryInc+SDqueryOut))
657 >        double          inc_psa, out_psa;
658 >                                        /* check arguments */
659 >        if ((psa == NULL) | (vec == NULL) | (dp == NULL))
660                  return SDEargument;
661 <        if (qflags & SDqueryInc) {
662 <                double  inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
663 <                if (inc_psa < .0)
664 <                        return SDEinternal;
665 <                switch (qflags & SDqueryMin+SDqueryMax) {
666 <                case SDqueryMax:
667 <                        if (inc_psa > psa[0])
668 <                                psa[0] = inc_psa;
669 <                        break;
670 <                case SDqueryMin+SDqueryMax:
672 <                        if (inc_psa > psa[1])
673 <                                psa[1] = inc_psa;
674 <                        /* fall through */
675 <                case SDqueryMin:
676 <                        if (inc_psa < psa[0])
677 <                                psa[0] = inc_psa;
678 <                        break;
679 <                case 0:
661 >                                        /* get projected solid angles */
662 >        inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
663 >        out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
664 >
665 >        switch (qflags) {               /* record based on flag settings */
666 >        case SDqueryVal:
667 >                psa[0] = .0;
668 >                /* fall through */
669 >        case SDqueryMax:
670 >                if (inc_psa > psa[0])
671                          psa[0] = inc_psa;
672 <                        break;
673 <                }
672 >                if (out_psa > psa[0])
673 >                        psa[0] = out_psa;
674 >                break;
675 >        case SDqueryMin+SDqueryMax:
676 >                if (inc_psa > psa[0])
677 >                        psa[1] = inc_psa;
678 >                if (out_psa > psa[0])
679 >                        psa[1] = out_psa;
680 >                /* fall through */
681 >        case SDqueryMin:
682 >                if ((inc_psa > .0) & (inc_psa < psa[0]))
683 >                        psa[0] = inc_psa;
684 >                if ((out_psa > .0) & (out_psa < psa[0]))
685 >                        psa[0] = out_psa;
686 >                break;
687          }
688 <        if (qflags & SDqueryOut) {
689 <                double  out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
686 <                if (out_psa < .0)
687 <                        return SDEinternal;
688 <                switch (qflags & SDqueryMin+SDqueryMax) {
689 <                case SDqueryMax:
690 <                        if (out_psa > psa[0])
691 <                                psa[0] = out_psa;
692 <                        break;
693 <                case SDqueryMin+SDqueryMax:
694 <                        if (out_psa > psa[1])
695 <                                psa[1] = out_psa;
696 <                        /* fall through */
697 <                case SDqueryMin:
698 <                        if (out_psa < psa[0])
699 <                                psa[0] = out_psa;
700 <                        break;
701 <                case 0:
702 <                        psa[(qflags&SDqueryInc)!=0] = out_psa;
703 <                        break;
704 <                }
705 <        }
706 <        return SDEnone;
688 >                                        /* make sure it's legal */
689 >        return (psa[0] <= .0) ? SDEinternal : SDEnone;
690   }
691  
692   /* Compute new cumulative distribution from BSDF */
# Line 745 | Line 728 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
728          int             reverse;
729          SDMatCDst       myCD;
730          SDMatCDst       *cd, *cdlast;
731 <
732 <        if (dp == NULL)
731 >                                        /* check arguments */
732 >        if ((inVec == NULL) | (dp == NULL))
733                  return NULL;
734          memset(&myCD, 0, sizeof(myCD));
735          myCD.indx = mBSDF_incndx(dp, inVec);
# Line 801 | Line 784 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
784          const SDMatCDst *mcd = (const SDMatCDst *)cdp;
785          const unsigned  target = randX*maxval;
786          int             i, iupper, ilower;
787 +                                        /* check arguments */
788 +        if ((outVec == NULL) | (mcd == NULL))
789 +                return SDEargument;
790                                          /* binary search to find index */
791          ilower = 0; iupper = mcd->calen;
792          while ((i = (iupper + ilower) >> 1) != ilower)
# Line 812 | Line 798 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
798          randX = (randX*maxval - mcd->carr[ilower]) /
799                          (double)(mcd->carr[iupper] - mcd->carr[ilower]);
800                                          /* convert index to vector */
801 <        if ((*mcd->ob_vec)(outVec, i, randX, mcd->ob_priv))
801 >        if ((*mcd->ob_vec)(outVec, i+randX, mcd->ob_priv))
802                  return SDEnone;
803          strcpy(SDerrorDetail, "BSDF sampling fault");
804          return SDEinternal;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines