Changeset 2681


Ignore:
Timestamp:
Nov 15, 2011 11:56:51 AM (11 years ago)
Author:
gah
Message:
 
Location:
branches/blt4/packages/vizservers
Files:
1 added
1 deleted
49 edited

Legend:

Unmodified
Added
Removed
  • branches/blt4/packages/vizservers/configure

    r2558 r2681  
    659659DL_OBJS
    660660DL_LIBS
     661AR
     662RANLIB
    661663EGREP
    662664GREP
    663665CPP
    664 AR
    665 RANLIB
    666666OBJEXT
    667667EXEEXT
     
    671671CFLAGS
    672672CC
     673PYTHON
    673674target_alias
    674675host_alias
     
    717718with_vtk_libs
    718719with_vtk
     720with_python
    719721enable_64bit
    720722enable_64bit_vis
     
    13671369  --with-vtk-libs=DIR     VTK libraries are in DIR
    13681370  --with-vtk=VERSION      Version of VTK required
     1371  --with-python=DIR       location of python [default=yes]
    13691372  --with-x                use the X Window System
    13701373
     
    15001503
    15011504} # ac_fn_c_try_compile
     1505
     1506# ac_fn_c_try_cpp LINENO
     1507# ----------------------
     1508# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
     1509ac_fn_c_try_cpp ()
     1510{
     1511  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     1512  if { { ac_try="$ac_cpp conftest.$ac_ext"
     1513case "(($ac_try" in
     1514  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     1515  *) ac_try_echo=$ac_try;;
     1516esac
     1517eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
     1518$as_echo "$ac_try_echo"; } >&5
     1519  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
     1520  ac_status=$?
     1521  if test -s conftest.err; then
     1522    grep -v '^ *+' conftest.err >conftest.er1
     1523    cat conftest.er1 >&5
     1524    mv -f conftest.er1 conftest.err
     1525  fi
     1526  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     1527  test $ac_status = 0; } > conftest.i && {
     1528         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
     1529         test ! -s conftest.err
     1530       }; then :
     1531  ac_retval=0
     1532else
     1533  $as_echo "$as_me: failed program was:" >&5
     1534sed 's/^/| /' conftest.$ac_ext >&5
     1535
     1536    ac_retval=1
     1537fi
     1538  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     1539  as_fn_set_status $ac_retval
     1540
     1541} # ac_fn_c_try_cpp
     1542
     1543# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
     1544# -------------------------------------------------------
     1545# Tests whether HEADER exists, giving a warning if it cannot be compiled using
     1546# the include files in INCLUDES and setting the cache variable VAR
     1547# accordingly.
     1548ac_fn_c_check_header_mongrel ()
     1549{
     1550  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     1551  if eval \${$3+:} false; then :
     1552  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
     1553$as_echo_n "checking for $2... " >&6; }
     1554if eval \${$3+:} false; then :
     1555  $as_echo_n "(cached) " >&6
     1556fi
     1557eval ac_res=\$$3
     1558               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
     1559$as_echo "$ac_res" >&6; }
     1560else
     1561  # Is the header compilable?
     1562{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
     1563$as_echo_n "checking $2 usability... " >&6; }
     1564cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     1565/* end confdefs.h.  */
     1566$4
     1567#include <$2>
     1568_ACEOF
     1569if ac_fn_c_try_compile "$LINENO"; then :
     1570  ac_header_compiler=yes
     1571else
     1572  ac_header_compiler=no
     1573fi
     1574rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     1575{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
     1576$as_echo "$ac_header_compiler" >&6; }
     1577
     1578# Is the header present?
     1579{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
     1580$as_echo_n "checking $2 presence... " >&6; }
     1581cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     1582/* end confdefs.h.  */
     1583#include <$2>
     1584_ACEOF
     1585if ac_fn_c_try_cpp "$LINENO"; then :
     1586  ac_header_preproc=yes
     1587else
     1588  ac_header_preproc=no
     1589fi
     1590rm -f conftest.err conftest.i conftest.$ac_ext
     1591{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
     1592$as_echo "$ac_header_preproc" >&6; }
     1593
     1594# So?  What about this header?
     1595case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
     1596  yes:no: )
     1597    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
     1598$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
     1599    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
     1600$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
     1601    ;;
     1602  no:yes:* )
     1603    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
     1604$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
     1605    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
     1606$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
     1607    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
     1608$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
     1609    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
     1610$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
     1611    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
     1612$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
     1613( $as_echo "## ----------------------------------- ##
     1614## Report this to rappture@nanohub.org ##
     1615## ----------------------------------- ##"
     1616     ) | sed "s/^/$as_me: WARNING:     /" >&2
     1617    ;;
     1618esac
     1619  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
     1620$as_echo_n "checking for $2... " >&6; }
     1621if eval \${$3+:} false; then :
     1622  $as_echo_n "(cached) " >&6
     1623else
     1624  eval "$3=\$ac_header_compiler"
     1625fi
     1626eval ac_res=\$$3
     1627               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
     1628$as_echo "$ac_res" >&6; }
     1629fi
     1630  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     1631
     1632} # ac_fn_c_check_header_mongrel
     1633
     1634# ac_fn_c_try_run LINENO
     1635# ----------------------
     1636# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
     1637# that executables *can* be run.
     1638ac_fn_c_try_run ()
     1639{
     1640  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     1641  if { { ac_try="$ac_link"
     1642case "(($ac_try" in
     1643  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     1644  *) ac_try_echo=$ac_try;;
     1645esac
     1646eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
     1647$as_echo "$ac_try_echo"; } >&5
     1648  (eval "$ac_link") 2>&5
     1649  ac_status=$?
     1650  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     1651  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
     1652  { { case "(($ac_try" in
     1653  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     1654  *) ac_try_echo=$ac_try;;
     1655esac
     1656eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
     1657$as_echo "$ac_try_echo"; } >&5
     1658  (eval "$ac_try") 2>&5
     1659  ac_status=$?
     1660  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
     1661  test $ac_status = 0; }; }; then :
     1662  ac_retval=0
     1663else
     1664  $as_echo "$as_me: program exited with status $ac_status" >&5
     1665       $as_echo "$as_me: failed program was:" >&5
     1666sed 's/^/| /' conftest.$ac_ext >&5
     1667
     1668       ac_retval=$ac_status
     1669fi
     1670  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
     1671  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     1672  as_fn_set_status $ac_retval
     1673
     1674} # ac_fn_c_try_run
     1675
     1676# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
     1677# -------------------------------------------------------
     1678# Tests whether HEADER exists and can be compiled using the include files in
     1679# INCLUDES, setting the cache variable VAR accordingly.
     1680ac_fn_c_check_header_compile ()
     1681{
     1682  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     1683  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
     1684$as_echo_n "checking for $2... " >&6; }
     1685if eval \${$3+:} false; then :
     1686  $as_echo_n "(cached) " >&6
     1687else
     1688  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     1689/* end confdefs.h.  */
     1690$4
     1691#include <$2>
     1692_ACEOF
     1693if ac_fn_c_try_compile "$LINENO"; then :
     1694  eval "$3=yes"
     1695else
     1696  eval "$3=no"
     1697fi
     1698rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     1699fi
     1700eval ac_res=\$$3
     1701               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
     1702$as_echo "$ac_res" >&6; }
     1703  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     1704
     1705} # ac_fn_c_check_header_compile
    15021706
    15031707# ac_fn_c_try_link LINENO
     
    15471751} # ac_fn_c_try_link
    15481752
    1549 # ac_fn_c_try_cpp LINENO
    1550 # ----------------------
    1551 # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
    1552 ac_fn_c_try_cpp ()
    1553 {
    1554   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1555   if { { ac_try="$ac_cpp conftest.$ac_ext"
    1556 case "(($ac_try" in
    1557   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1558   *) ac_try_echo=$ac_try;;
    1559 esac
    1560 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1561 $as_echo "$ac_try_echo"; } >&5
    1562   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
    1563   ac_status=$?
    1564   if test -s conftest.err; then
    1565     grep -v '^ *+' conftest.err >conftest.er1
    1566     cat conftest.er1 >&5
    1567     mv -f conftest.er1 conftest.err
    1568   fi
    1569   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1570   test $ac_status = 0; } > conftest.i && {
    1571          test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
    1572          test ! -s conftest.err
    1573        }; then :
    1574   ac_retval=0
    1575 else
    1576   $as_echo "$as_me: failed program was:" >&5
    1577 sed 's/^/| /' conftest.$ac_ext >&5
    1578 
    1579     ac_retval=1
    1580 fi
    1581   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1582   as_fn_set_status $ac_retval
    1583 
    1584 } # ac_fn_c_try_cpp
    1585 
    1586 # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
    1587 # -------------------------------------------------------
    1588 # Tests whether HEADER exists, giving a warning if it cannot be compiled using
    1589 # the include files in INCLUDES and setting the cache variable VAR
    1590 # accordingly.
    1591 ac_fn_c_check_header_mongrel ()
    1592 {
    1593   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1594   if eval \${$3+:} false; then :
    1595   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    1596 $as_echo_n "checking for $2... " >&6; }
    1597 if eval \${$3+:} false; then :
    1598   $as_echo_n "(cached) " >&6
    1599 fi
    1600 eval ac_res=\$$3
    1601                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    1602 $as_echo "$ac_res" >&6; }
    1603 else
    1604   # Is the header compilable?
    1605 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
    1606 $as_echo_n "checking $2 usability... " >&6; }
    1607 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    1608 /* end confdefs.h.  */
    1609 $4
    1610 #include <$2>
    1611 _ACEOF
    1612 if ac_fn_c_try_compile "$LINENO"; then :
    1613   ac_header_compiler=yes
    1614 else
    1615   ac_header_compiler=no
    1616 fi
    1617 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    1618 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
    1619 $as_echo "$ac_header_compiler" >&6; }
    1620 
    1621 # Is the header present?
    1622 { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
    1623 $as_echo_n "checking $2 presence... " >&6; }
    1624 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    1625 /* end confdefs.h.  */
    1626 #include <$2>
    1627 _ACEOF
    1628 if ac_fn_c_try_cpp "$LINENO"; then :
    1629   ac_header_preproc=yes
    1630 else
    1631   ac_header_preproc=no
    1632 fi
    1633 rm -f conftest.err conftest.i conftest.$ac_ext
    1634 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
    1635 $as_echo "$ac_header_preproc" >&6; }
    1636 
    1637 # So?  What about this header?
    1638 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
    1639   yes:no: )
    1640     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
    1641 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    1642     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
    1643 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    1644     ;;
    1645   no:yes:* )
    1646     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
    1647 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    1648     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
    1649 $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    1650     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
    1651 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    1652     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
    1653 $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    1654     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
    1655 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    1656 ( $as_echo "## ----------------------------------- ##
    1657 ## Report this to rappture@nanohub.org ##
    1658 ## ----------------------------------- ##"
    1659      ) | sed "s/^/$as_me: WARNING:     /" >&2
    1660     ;;
    1661 esac
    1662   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    1663 $as_echo_n "checking for $2... " >&6; }
    1664 if eval \${$3+:} false; then :
    1665   $as_echo_n "(cached) " >&6
    1666 else
    1667   eval "$3=\$ac_header_compiler"
    1668 fi
    1669 eval ac_res=\$$3
    1670                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    1671 $as_echo "$ac_res" >&6; }
    1672 fi
    1673   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1674 
    1675 } # ac_fn_c_check_header_mongrel
    1676 
    1677 # ac_fn_c_try_run LINENO
    1678 # ----------------------
    1679 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
    1680 # that executables *can* be run.
    1681 ac_fn_c_try_run ()
    1682 {
    1683   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1684   if { { ac_try="$ac_link"
    1685 case "(($ac_try" in
    1686   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1687   *) ac_try_echo=$ac_try;;
    1688 esac
    1689 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1690 $as_echo "$ac_try_echo"; } >&5
    1691   (eval "$ac_link") 2>&5
    1692   ac_status=$?
    1693   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1694   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
    1695   { { case "(($ac_try" in
    1696   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    1697   *) ac_try_echo=$ac_try;;
    1698 esac
    1699 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    1700 $as_echo "$ac_try_echo"; } >&5
    1701   (eval "$ac_try") 2>&5
    1702   ac_status=$?
    1703   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    1704   test $ac_status = 0; }; }; then :
    1705   ac_retval=0
    1706 else
    1707   $as_echo "$as_me: program exited with status $ac_status" >&5
    1708        $as_echo "$as_me: failed program was:" >&5
    1709 sed 's/^/| /' conftest.$ac_ext >&5
    1710 
    1711        ac_retval=$ac_status
    1712 fi
    1713   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
    1714   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1715   as_fn_set_status $ac_retval
    1716 
    1717 } # ac_fn_c_try_run
    1718 
    1719 # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
    1720 # -------------------------------------------------------
    1721 # Tests whether HEADER exists and can be compiled using the include files in
    1722 # INCLUDES, setting the cache variable VAR accordingly.
    1723 ac_fn_c_check_header_compile ()
    1724 {
    1725   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    1726   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    1727 $as_echo_n "checking for $2... " >&6; }
    1728 if eval \${$3+:} false; then :
    1729   $as_echo_n "(cached) " >&6
    1730 else
    1731   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    1732 /* end confdefs.h.  */
    1733 $4
    1734 #include <$2>
    1735 _ACEOF
    1736 if ac_fn_c_try_compile "$LINENO"; then :
    1737   eval "$3=yes"
    1738 else
    1739   eval "$3=no"
    1740 fi
    1741 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    1742 fi
    1743 eval ac_res=\$$3
    1744                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    1745 $as_echo "$ac_res" >&6; }
    1746   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    1747 
    1748 } # ac_fn_c_check_header_compile
    1749 
    17501753# ac_fn_cxx_try_compile LINENO
    17511754# ----------------------------
     
    21802183} # ac_fn_cxx_try_link
    21812184
    2182 # ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
    2183 # ---------------------------------------------------------
    2184 # Tests whether HEADER exists and can be compiled using the include files in
    2185 # INCLUDES, setting the cache variable VAR accordingly.
    2186 ac_fn_cxx_check_header_compile ()
    2187 {
    2188   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    2189   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
    2190 $as_echo_n "checking for $2... " >&6; }
    2191 if eval \${$3+:} false; then :
    2192   $as_echo_n "(cached) " >&6
    2193 else
    2194   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    2195 /* end confdefs.h.  */
    2196 $4
    2197 #include <$2>
    2198 _ACEOF
    2199 if ac_fn_cxx_try_compile "$LINENO"; then :
    2200   eval "$3=yes"
    2201 else
    2202   eval "$3=no"
    2203 fi
    2204 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    2205 fi
    2206 eval ac_res=\$$3
    2207                { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
    2208 $as_echo "$ac_res" >&6; }
    2209   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
    2210 
    2211 } # ac_fn_cxx_check_header_compile
    2212 
    22132185# ac_fn_cxx_check_func LINENO FUNC VAR
    22142186# ------------------------------------
     
    22772249
    22782250} # ac_fn_cxx_check_func
     2251
     2252# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
     2253# ---------------------------------------------------------
     2254# Tests whether HEADER exists and can be compiled using the include files in
     2255# INCLUDES, setting the cache variable VAR accordingly.
     2256ac_fn_cxx_check_header_compile ()
     2257{
     2258  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
     2259  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
     2260$as_echo_n "checking for $2... " >&6; }
     2261if eval \${$3+:} false; then :
     2262  $as_echo_n "(cached) " >&6
     2263else
     2264  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
     2265/* end confdefs.h.  */
     2266$4
     2267#include <$2>
     2268_ACEOF
     2269if ac_fn_cxx_try_compile "$LINENO"; then :
     2270  eval "$3=yes"
     2271else
     2272  eval "$3=no"
     2273fi
     2274rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     2275fi
     2276eval ac_res=\$$3
     2277               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
     2278$as_echo "$ac_res" >&6; }
     2279  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
     2280
     2281} # ac_fn_cxx_check_header_compile
    22792282cat >config.log <<_ACEOF
    22802283This file contains any messages produced by compilers while
     
    26292632
    26302633
     2634ac_aux_dir=
     2635for ac_dir in cf "$srcdir"/cf; do
     2636  if test -f "$ac_dir/install-sh"; then
     2637    ac_aux_dir=$ac_dir
     2638    ac_install_sh="$ac_aux_dir/install-sh -c"
     2639    break
     2640  elif test -f "$ac_dir/install.sh"; then
     2641    ac_aux_dir=$ac_dir
     2642    ac_install_sh="$ac_aux_dir/install.sh -c"
     2643    break
     2644  elif test -f "$ac_dir/shtool"; then
     2645    ac_aux_dir=$ac_dir
     2646    ac_install_sh="$ac_aux_dir/shtool install -c"
     2647    break
     2648  fi
     2649done
     2650if test -z "$ac_aux_dir"; then
     2651  as_fn_error $? "cannot find install-sh, install.sh, or shtool in cf \"$srcdir\"/cf" "$LINENO" 5
     2652fi
     2653
     2654# These three variables are undocumented and unsupported,
     2655# and are intended to be withdrawn in a future Autoconf release.
     2656# They can cause serious problems if a builder's source tree is in a directory
     2657# whose full name contains unusual characters.
     2658ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
     2659ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
     2660ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
     2661
     2662
    26312663ac_config_headers="$ac_config_headers nanovis/nvconf.h nanoscale/config.h"
    26322664
     
    26762708fi
    26772709
    2678 
    2679 VERSION=0.0.1
    2680 
    2681 #------------------------------------------------------------------------
    2682 # Handle the --prefix=... option
    2683 #------------------------------------------------------------------------
    2684 
    2685 if test "${prefix}" = "NONE"; then
    2686     prefix=/usr/local
    2687 fi
    2688 if test "${exec_prefix}" = "NONE"; then
    2689     exec_prefix=$prefix
    2690 fi
    2691 
    2692 if test "x${incdir}" == "x"; then
    2693   incdir=${exec_prefix}/include
    2694 fi
    2695 libdir=${exec_prefix}/lib
    2696 
    2697 if test "${libdir}" != "${prefix}/lib"; then
    2698     LIB_SEARCH_DIRS="-L ${prefix}/lib -L ${libdir}"
    2699 else
    2700     LIB_SEARCH_DIRS="-L ${libdir}"
    2701 fi
    27022710
    27032711ac_ext=c
     
    34923500
    34933501
    3494 if test -n "$ac_tool_prefix"; then
    3495   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
    3496 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
    3497 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3498 $as_echo_n "checking for $ac_word... " >&6; }
    3499 if ${ac_cv_prog_RANLIB+:} false; then :
    3500   $as_echo_n "(cached) " >&6
    3501 else
    3502   if test -n "$RANLIB"; then
    3503   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
    3504 else
    3505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3506 for as_dir in $PATH
    3507 do
    3508   IFS=$as_save_IFS
    3509   test -z "$as_dir" && as_dir=.
    3510     for ac_exec_ext in '' $ac_executable_extensions; do
    3511   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    3512     ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
    3513     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3514     break 2
    3515   fi
    3516 done
    3517   done
    3518 IFS=$as_save_IFS
    3519 
    3520 fi
    3521 fi
    3522 RANLIB=$ac_cv_prog_RANLIB
    3523 if test -n "$RANLIB"; then
    3524   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
    3525 $as_echo "$RANLIB" >&6; }
    3526 else
    3527   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3528 $as_echo "no" >&6; }
    3529 fi
    3530 
    3531 
    3532 fi
    3533 if test -z "$ac_cv_prog_RANLIB"; then
    3534   ac_ct_RANLIB=$RANLIB
    3535   # Extract the first word of "ranlib", so it can be a program name with args.
    3536 set dummy ranlib; ac_word=$2
    3537 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3538 $as_echo_n "checking for $ac_word... " >&6; }
    3539 if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
    3540   $as_echo_n "(cached) " >&6
    3541 else
    3542   if test -n "$ac_ct_RANLIB"; then
    3543   ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
    3544 else
    3545 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3546 for as_dir in $PATH
    3547 do
    3548   IFS=$as_save_IFS
    3549   test -z "$as_dir" && as_dir=.
    3550     for ac_exec_ext in '' $ac_executable_extensions; do
    3551   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
    3552     ac_cv_prog_ac_ct_RANLIB="ranlib"
    3553     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3554     break 2
    3555   fi
    3556 done
    3557   done
    3558 IFS=$as_save_IFS
    3559 
    3560 fi
    3561 fi
    3562 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
    3563 if test -n "$ac_ct_RANLIB"; then
    3564   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
    3565 $as_echo "$ac_ct_RANLIB" >&6; }
    3566 else
    3567   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3568 $as_echo "no" >&6; }
    3569 fi
    3570 
    3571   if test "x$ac_ct_RANLIB" = x; then
    3572     RANLIB=":"
    3573   else
    3574     case $cross_compiling:$ac_tool_warned in
    3575 yes:)
    3576 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    3577 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    3578 ac_tool_warned=yes ;;
    3579 esac
    3580     RANLIB=$ac_ct_RANLIB
    3581   fi
    3582 else
    3583   RANLIB="$ac_cv_prog_RANLIB"
    3584 fi
    3585 
    35863502ac_ext=c
    35873503ac_cpp='$CPP $CPPFLAGS'
     
    39803896done
    39813897
     3898
     3899
     3900PYTHON=""
     3901PYTHON_CFLAGS=""
     3902PYTHON_CPPFLAGS=""
     3903PYTHON_DISTUTILS=""
     3904PYTHON_INCLUDES=""
     3905PYTHON_LDFLAGS=""
     3906PYTHON_LIB=""
     3907PYTHON_LIBDIR=""
     3908PYTHON_SITE_DIR=""
     3909PYTHON_SITE_PACKAGES=""
     3910PYTHON_VERSION=""
     3911pythondir=""
     3912
     3913# Check whether --with-python was given.
     3914if test "${with_python+set}" = set; then :
     3915  withval=$with_python;
     3916else
     3917  with_python=yes
     3918fi
     3919
     3920
     3921if test "$with_python" != "no" ; then
     3922  if test "$with_python" = "yes" ; then
     3923    # Extract the first word of "python python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5", so it can be a program name with args.
     3924set dummy python python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 python1.6 python1.5; ac_word=$2
     3925{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3926$as_echo_n "checking for $ac_word... " >&6; }
     3927if ${ac_cv_path_PYTHON+:} false; then :
     3928  $as_echo_n "(cached) " >&6
     3929else
     3930  case $PYTHON in
     3931  [\\/]* | ?:[\\/]*)
     3932  ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
     3933  ;;
     3934  *)
     3935  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3936for as_dir in $PATH
     3937do
     3938  IFS=$as_save_IFS
     3939  test -z "$as_dir" && as_dir=.
     3940    for ac_exec_ext in '' $ac_executable_extensions; do
     3941  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     3942    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
     3943    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3944    break 2
     3945  fi
     3946done
     3947  done
     3948IFS=$as_save_IFS
     3949
     3950  ;;
     3951esac
     3952fi
     3953PYTHON=$ac_cv_path_PYTHON
     3954if test -n "$PYTHON"; then
     3955  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
     3956$as_echo "$PYTHON" >&6; }
     3957else
     3958  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     3959$as_echo "no" >&6; }
     3960fi
     3961
     3962
     3963  else
     3964    # Extract the first word of "python", so it can be a program name with args.
     3965set dummy python; ac_word=$2
     3966{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     3967$as_echo_n "checking for $ac_word... " >&6; }
     3968if ${ac_cv_path_PYTHON+:} false; then :
     3969  $as_echo_n "(cached) " >&6
     3970else
     3971  case $PYTHON in
     3972  [\\/]* | ?:[\\/]*)
     3973  ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
     3974  ;;
     3975  *)
     3976  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     3977as_dummy="${with_python}/bin:${with_python}"
     3978for as_dir in $as_dummy
     3979do
     3980  IFS=$as_save_IFS
     3981  test -z "$as_dir" && as_dir=.
     3982    for ac_exec_ext in '' $ac_executable_extensions; do
     3983  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     3984    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
     3985    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     3986    break 2
     3987  fi
     3988done
     3989  done
     3990IFS=$as_save_IFS
     3991
     3992  ;;
     3993esac
     3994fi
     3995PYTHON=$ac_cv_path_PYTHON
     3996if test -n "$PYTHON"; then
     3997  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
     3998$as_echo "$PYTHON" >&6; }
     3999else
     4000  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4001$as_echo "no" >&6; }
     4002fi
     4003
     4004
     4005  fi
     4006  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python version" >&5
     4007$as_echo_n "checking for Python version... " >&6; }
     4008  if test "x${PYTHON}" != "x"; then
     4009    PYTHON_VERSION=`${PYTHON} -c "import sys; print sys.version[0:3]"`
     4010  fi
     4011  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_VERSION" >&5
     4012$as_echo "$PYTHON_VERSION" >&6; }
     4013fi
     4014
     4015if test "x${PYTHON_VERSION}" != "x"; then
     4016  PYTHON_INCLUDES=$incdir
     4017  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python distutils" >&5
     4018$as_echo_n "checking for Python distutils... " >&6; }
     4019  PYTHON_DISTUTILS=""
     4020  ${PYTHON} -c "from distutils.core import setup; setup(name='test')" \
     4021        build build_ext 2>&1 > /dev/null
     4022  if test $? = 0 ; then
     4023    PYTHON_DISTUTILS="yes"
     4024  fi
     4025  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_DISTUTILS" >&5
     4026$as_echo "$PYTHON_DISTUTILS" >&6; }
     4027  if test "${PYTHON_DISTUTILS}" = "yes" ; then
     4028    PYTHON_SITE_PACKAGES=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_lib()"`
     4029    #
     4030    # Check for Python include path
     4031    #
     4032    { $as_echo "$as_me:${as_lineno-$LINENO}: checking path to Python headers" >&5
     4033$as_echo_n "checking path to Python headers... " >&6; }
     4034    PYTHON_INCDIR=`${PYTHON} -c "import distutils.sysconfig; \
     4035     print distutils.sysconfig.get_python_inc();"`
     4036    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_INCDIR" >&5
     4037$as_echo "$PYTHON_INCDIR" >&6; }
     4038    #
     4039    # Python distutils found, get settings from python directly
     4040    #
     4041    PYTHON_SITE_DIR="`${PYTHON} -c 'from distutils import sysconfig; print sysconfig.get_python_lib(0);'`"
     4042
     4043    PYTHON_CFLAGS="`$PYTHON -c 'from distutils import sysconfig; flags = [\"-I\" + sysconfig.get_python_inc(0), \"-I\" + sysconfig.get_python_inc(1), \" \".join(sysconfig.get_config_var(\"CFLAGS\").split())]; print \" \".join(flags);'`"
     4044    PYTHON_LDFLAGS="`$PYTHON -c 'from distutils import sysconfig; libs = sysconfig.get_config_var(\"LIBS\").split() + sysconfig.get_config_var(\"SYSLIBS\").split(); libs.append(\"-lpython\"+sysconfig.get_config_var(\"VERSION\")); print \" \".join(libs);'`"
     4045    PYTHON_LIB="`$PYTHON -c 'from distutils import sysconfig; print \"python\" + sysconfig.get_config_var(\"VERSION\");'`"
     4046    PYTHON_LIBDIR="`$PYTHON -c 'from distutils import sysconfig; print sysconfig.get_config_var(\"LIBDIR\");'`"
     4047    save_CPPFLAGS=$CPPFLAGS
     4048    CPPFLAGS="$CPPFLAGS -I${PYTHON_INCDIR}"
     4049    for ac_header in Python.h
     4050do :
     4051  ac_fn_c_check_header_mongrel "$LINENO" "Python.h" "ac_cv_header_Python_h" "$ac_includes_default"
     4052if test "x$ac_cv_header_Python_h" = xyes; then :
     4053  cat >>confdefs.h <<_ACEOF
     4054#define HAVE_PYTHON_H 1
     4055_ACEOF
     4056 found=yes
     4057else
     4058  found=no
     4059fi
     4060
     4061done
     4062
     4063    CPPFLAGS=$save_CPPFLAGS
     4064    if test "$found" = "no" ; then
     4065      PYTHON_DISTUTILS=""
     4066    fi
     4067  fi
     4068fi
     4069
     4070
     4071VERSION=0.0.1
     4072
     4073#------------------------------------------------------------------------
     4074# Handle the --prefix=... option
     4075#------------------------------------------------------------------------
     4076
     4077if test "${prefix}" = "NONE"; then
     4078    prefix=/usr/local
     4079fi
     4080if test "${exec_prefix}" = "NONE"; then
     4081    exec_prefix=$prefix
     4082fi
     4083
     4084if test "x${incdir}" == "x"; then
     4085  incdir=${exec_prefix}/include
     4086fi
     4087libdir=${exec_prefix}/lib
     4088
     4089if test "${libdir}" != "${prefix}/lib"; then
     4090    LIB_SEARCH_DIRS="-L ${prefix}/lib -L ${libdir}"
     4091else
     4092    LIB_SEARCH_DIRS="-L ${libdir}"
     4093fi
     4094
     4095if test -n "$ac_tool_prefix"; then
     4096  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
     4097set dummy ${ac_tool_prefix}ranlib; ac_word=$2
     4098{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4099$as_echo_n "checking for $ac_word... " >&6; }
     4100if ${ac_cv_prog_RANLIB+:} false; then :
     4101  $as_echo_n "(cached) " >&6
     4102else
     4103  if test -n "$RANLIB"; then
     4104  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
     4105else
     4106as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4107for as_dir in $PATH
     4108do
     4109  IFS=$as_save_IFS
     4110  test -z "$as_dir" && as_dir=.
     4111    for ac_exec_ext in '' $ac_executable_extensions; do
     4112  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4113    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
     4114    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4115    break 2
     4116  fi
     4117done
     4118  done
     4119IFS=$as_save_IFS
     4120
     4121fi
     4122fi
     4123RANLIB=$ac_cv_prog_RANLIB
     4124if test -n "$RANLIB"; then
     4125  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
     4126$as_echo "$RANLIB" >&6; }
     4127else
     4128  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4129$as_echo "no" >&6; }
     4130fi
     4131
     4132
     4133fi
     4134if test -z "$ac_cv_prog_RANLIB"; then
     4135  ac_ct_RANLIB=$RANLIB
     4136  # Extract the first word of "ranlib", so it can be a program name with args.
     4137set dummy ranlib; ac_word=$2
     4138{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     4139$as_echo_n "checking for $ac_word... " >&6; }
     4140if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
     4141  $as_echo_n "(cached) " >&6
     4142else
     4143  if test -n "$ac_ct_RANLIB"; then
     4144  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
     4145else
     4146as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     4147for as_dir in $PATH
     4148do
     4149  IFS=$as_save_IFS
     4150  test -z "$as_dir" && as_dir=.
     4151    for ac_exec_ext in '' $ac_executable_extensions; do
     4152  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     4153    ac_cv_prog_ac_ct_RANLIB="ranlib"
     4154    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     4155    break 2
     4156  fi
     4157done
     4158  done
     4159IFS=$as_save_IFS
     4160
     4161fi
     4162fi
     4163ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
     4164if test -n "$ac_ct_RANLIB"; then
     4165  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
     4166$as_echo "$ac_ct_RANLIB" >&6; }
     4167else
     4168  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     4169$as_echo "no" >&6; }
     4170fi
     4171
     4172  if test "x$ac_ct_RANLIB" = x; then
     4173    RANLIB=":"
     4174  else
     4175    case $cross_compiling:$ac_tool_warned in
     4176yes:)
     4177{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
     4178$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
     4179ac_tool_warned=yes ;;
     4180esac
     4181    RANLIB=$ac_ct_RANLIB
     4182  fi
     4183else
     4184  RANLIB="$ac_cv_prog_RANLIB"
     4185fi
    39824186
    39834187
     
    59906194
    59916195
    5992 ac_aux_dir=
    5993 for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
    5994   if test -f "$ac_dir/install-sh"; then
    5995     ac_aux_dir=$ac_dir
    5996     ac_install_sh="$ac_aux_dir/install-sh -c"
    5997     break
    5998   elif test -f "$ac_dir/install.sh"; then
    5999     ac_aux_dir=$ac_dir
    6000     ac_install_sh="$ac_aux_dir/install.sh -c"
    6001     break
    6002   elif test -f "$ac_dir/shtool"; then
    6003     ac_aux_dir=$ac_dir
    6004     ac_install_sh="$ac_aux_dir/shtool install -c"
    6005     break
    6006   fi
    6007 done
    6008 if test -z "$ac_aux_dir"; then
    6009   as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
    6010 fi
    6011 
    6012 # These three variables are undocumented and unsupported,
    6013 # and are intended to be withdrawn in a future Autoconf release.
    6014 # They can cause serious problems if a builder's source tree is in a directory
    6015 # whose full name contains unusual characters.
    6016 ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
    6017 ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
    6018 ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
    6019 
    6020 
    60216196# Find a good install program.  We prefer a C program (faster),
    60226197# so one script is as good as another.  But avoid the broken or
     
    80968271
    80978272else
    8098   as_fn_error $? "cannot find VTK includes" "$LINENO" 5
     8273  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find vtkSmartPointer.h" >&5
     8274$as_echo "$as_me: WARNING: cannot find vtkSmartPointer.h" >&2;}
    80998275fi
    81008276
     
    81528328fi
    81538329
     8330done
     8331
     8332
     8333for ac_func in accept4
     8334do :
     8335  ac_fn_cxx_check_func "$LINENO" "accept4" "ac_cv_func_accept4"
     8336if test "x$ac_cv_func_accept4" = xyes; then :
     8337  cat >>confdefs.h <<_ACEOF
     8338#define HAVE_ACCEPT4 1
     8339_ACEOF
     8340
     8341fi
    81548342done
    81558343
     
    81698357done
    81708358if test "x${DX_INC_DIR}" = "x" ; then
    8171   as_fn_error $? "cannot find OpenDX include files" "$LINENO" 5
    8172 fi
    8173 
    8174 if test "${DX_INC_DIR}" = "/usr/include" ; then
     8359  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find OpenDX include files" >&5
     8360$as_echo "$as_me: WARNING: cannot find OpenDX include files" >&2;}
    81758361  DX_INC_SPEC=""
     8362elif test "${DX_INC_DIR}" = "/usr/include" ; then
     8363  DX_INC_SPEC=""
    81768364else
    81778365  DX_INC_SPEC="-I{DX_INC_DIR}"
    81788366fi
     8367
    81798368{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${DX_INC_DIR}" >&5
    81808369$as_echo "${DX_INC_DIR}" >&6; }
     8370save_CPPFLAGS=${CPPFLAGS}
     8371CPPFLAGS="$DX_INC_SPEC $CPPFLAGS"
     8372for ac_header in dx/dx.h
     8373do :
     8374  ac_fn_cxx_check_header_mongrel "$LINENO" "dx/dx.h" "ac_cv_header_dx_dx_h" "$ac_includes_default"
     8375if test "x$ac_cv_header_dx_dx_h" = xyes; then :
     8376  cat >>confdefs.h <<_ACEOF
     8377#define HAVE_DX_DX_H 1
     8378_ACEOF
     8379
     8380fi
     8381
     8382done
     8383
     8384CPPFLAGS=${save_CPPFLAGS}
    81818385
    81828386DX_LIB_DIR=""
    8183 found=no
    81848387for dir in \
    81858388 /usr/lib \
     
    82418444  fi
    82428445done
    8243 if test "x{$DX_LIB_DIR}" = "x" ; then
    8244   as_fn_error $? "cannot find OpenDX libraries" "$LINENO" 5
     8446if test "x${DX_LIB_DIR}" = "x" ; then
     8447  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find OpenDX libraries" >&5
     8448$as_echo "$as_me: WARNING: cannot find OpenDX libraries" >&2;}
    82458449fi
    82468450
    82478451{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libDXcallm library" >&5
    82488452$as_echo_n "checking for libDXcallm library... " >&6; }
    8249 if test "${DX_LIB_DIR}" = "/usr/lib" -o "${DX_LIB_DIR}" = "/usr/lib64"; then
     8453if test "x${DX_LIB_DIR}" = "x" -o "${DX_LIB_DIR}" = "/usr/lib" -o "${DX_LIB_DIR}" = "/usr/lib64"; then
    82508454  DX_LIB_SPEC=""
    82518455else
    8252   DX_LIB_SPEC="-L${DX_LIB_DIR}"
     8456  DX_LIB_SPEC="-L${DX_LIB_DIR} -lDXcallm"
    82538457fi
    82548458{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DX_LIB_SPEC" >&5
     
    82688472done
    82698473
    8270 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cvLoadImage in -lcv" >&5
    8271 $as_echo_n "checking for cvLoadImage in -lcv... " >&6; }
    8272 if ${ac_cv_lib_cv_cvLoadImage+:} false; then :
     8474{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for cvLoadImage in -lhighgui" >&5
     8475$as_echo_n "checking for cvLoadImage in -lhighgui... " >&6; }
     8476if ${ac_cv_lib_highgui_cvLoadImage+:} false; then :
    82738477  $as_echo_n "(cached) " >&6
    82748478else
    82758479  ac_check_lib_save_LIBS=$LIBS
    8276 LIBS="-lcv  $LIBS"
     8480LIBS="-lhighgui  $LIBS"
    82778481cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    82788482/* end confdefs.h.  */
     
    82948498_ACEOF
    82958499if ac_fn_cxx_try_link "$LINENO"; then :
    8296   ac_cv_lib_cv_cvLoadImage=yes
    8297 else
    8298   ac_cv_lib_cv_cvLoadImage=no
     8500  ac_cv_lib_highgui_cvLoadImage=yes
     8501else
     8502  ac_cv_lib_highgui_cvLoadImage=no
    82998503fi
    83008504rm -f core conftest.err conftest.$ac_objext \
     
    83028506LIBS=$ac_check_lib_save_LIBS
    83038507fi
    8304 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_cv_cvLoadImage" >&5
    8305 $as_echo "$ac_cv_lib_cv_cvLoadImage" >&6; }
    8306 if test "x$ac_cv_lib_cv_cvLoadImage" = xyes; then :
     8508{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_highgui_cvLoadImage" >&5
     8509$as_echo "$ac_cv_lib_highgui_cvLoadImage" >&6; }
     8510if test "x$ac_cv_lib_highgui_cvLoadImage" = xyes; then :
    83078511  cat >>confdefs.h <<_ACEOF
    8308 #define HAVE_LIBCV 1
    8309 _ACEOF
    8310 
    8311   LIBS="-lcv $LIBS"
     8512#define HAVE_LIBHIGHGUI 1
     8513_ACEOF
     8514
     8515  LIBS="-lhighgui $LIBS"
    83128516
    83138517fi
     
    85858789
    85868790else
    8587   as_fn_error $? "cannot find nVidia Cg headers" "$LINENO" 5
     8791  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find nVidia Cg headers" >&5
     8792$as_echo "$as_me: WARNING: cannot find nVidia Cg headers" >&2;}
    85888793fi
    85898794
     
    85998804
    86008805SUBDIRS="nanoscale nanovis pymolproxy vtkvis"
     8806
    86018807
    86028808
  • branches/blt4/packages/vizservers/nanovis/Command.cpp

    r2409 r2681  
    12141214        }
    12151215#endif  /*__TEST_CODE__*/
    1216     } else if ((nBytes > 5) && (strncmp(bytes, "<ODX>", 5) == 0)) {
    1217         TRACE("Loading DX using OpenDX library...\n");
    1218         Rappture::Outcome context;
    1219         volPtr = load_volume_stream_odx(context, tag, bytes + 5, nBytes -5);
    1220         if (volPtr == NULL) {
    1221             Tcl_AppendResult(interp, context.remark(), (char*)NULL);
    1222             return TCL_ERROR;
    1223         }
    12241216    } else {
    1225         TRACE("OpenDX loading...\n");
     1217        TRACE("DX loading...\n");
    12261218        std::stringstream fdata;
    12271219        fdata.write(bytes, nBytes);
  • branches/blt4/packages/vizservers/nanovis/Makefile.in

    r2542 r2681  
    2828CG_INC_SPEC     = -I$(CG_DIR)/include
    2929CG_LIB_SPEC     = -L$(CG_DIR)/lib -lCg -lCgGL
    30 DX_INC_SPEC     = @DX_INC_SPEC@
    31 DX_LIB_SPEC     = @DX_LIB_SPEC@ -lDXcallm
    3230FF_LIB_SPEC     = @LIBS@
    3331FF_INC_SPEC     = @FF_INC_SPEC@
     
    7270LIBS            = \
    7371                $(RP_LIB_SPEC) \
    74                 $(DX_LIB_SPEC) \
    7572                $(IMG_LIB_SPEC) \
    7673                $(R2_LIB_SPEC) \
     
    156153                RenderVertexArray.o \
    157154                RpAVTranslate.o \
    158                 RpDX.o \
    159155                ScreenSnapper.o \
    160156                Sphere.o \
     
    173169                ZincBlendeVolume.o \
    174170                dxReader.o \
    175                 dxReader2.o \
    176171                dxReaderCommon.o \
    177172                nanovis.o
     
    252247        $(CXX) $(CXX_SWITCHES) -o $@ -c $<
    253248
    254 dxReader2.o: $(srcdir)/dxReader2.cpp
    255         $(CXX) -c $(CXX_SWITCHES) $(DX_INC_SPEC) $<
    256 RpDX.o: $(srcdir)/RpDX.cpp
    257         $(CXX) -c $(CXX_SWITCHES) $(DX_INC_SPEC) $<
    258249RpAVTranslate.o: $(srcdir)/RpAVTranslate.cpp
    259250        $(CXX) -c $(CXX_SWITCHES) $(FF_INC_SPEC) $<
     
    351342RenderVertexArray.o: RenderVertexArray.cpp RenderVertexArray.h
    352343RpAVTranslate.o: RpAVTranslate.cpp RpAVTranslate.h nvconf.h
    353 RpDX.o: RpDX.cpp RpDX.h Trace.h
    354344ScreenSnapper.o: ScreenSnapper.cpp ScreenSnapper.h define.h
    355345Sphere.o: Sphere.cpp Sphere.h
     
    368358ZincBlendeVolume.o: ZincBlendeVolume.cpp ZincBlendeVolume.h $(AUXSRC)
    369359dxReader.o: dxReader.cpp dxReaderCommon.h Nv.h nanovis.h Unirect.h ZincBlendeVolume.h NvZincBlendeReconstructor.h
    370 dxReader2.o: dxReader2.cpp dxReaderCommon.h RpDX.h Nv.h nanovis.h
    371360dxReaderCommon.o: dxReaderCommon.cpp dxReaderCommon.h GradientFilter.h Vector3.h
    372361nanovis.o: nanovis.cpp nanovis.h $(AUXSRC)
  • branches/blt4/packages/vizservers/nanovis/RpDX.cpp

    r2409 r2681  
    1414 * ======================================================================
    1515 */
     16#include "nvconf.h"
     17#ifdef HAVE_DX_DX_H
    1618#include "RpDX.h"
    1719#undef ERROR
     
    340342}
    341343
     344#endif /*HAVE_DX_DX_H*/
  • branches/blt4/packages/vizservers/nanovis/dxReader2.cpp

    r2409 r2681  
    11
     2#include "nvconf.h"
     3#ifdef HAVE_DX_DX_H
    24#include "RpDX.h"
    35#undef ERROR
     
    118120    return volPtr;
    119121}
     122#endif
  • branches/blt4/packages/vizservers/nanovis/nvconf.h.in

    r2542 r2681  
    1515/* Define to 1 if you have the <Cg/cgGL.h> header file. */
    1616#undef HAVE_CG_CGGL_H
     17
     18/* Define to 1 if you have the <dx/dx.h> header file. */
     19#undef HAVE_DX_DX_H
    1720
    1821/* Define to 1 if you have the <ffmpeg/avcodec.h> header file. */
     
    6770#undef HAVE_OPENCV_HIGHGUI_H
    6871
     72/* Define to 1 if you have the <Python.h> header file. */
     73#undef HAVE_PYTHON_H
     74
    6975/* Define to 1 if you have the <stdint.h> header file. */
    7076#undef HAVE_STDINT_H
     
    112118#undef PACKAGE_TARNAME
    113119
     120/* Define to the home page for this package. */
     121#undef PACKAGE_URL
     122
    114123/* Define to the version of this package. */
    115124#undef PACKAGE_VERSION
  • branches/blt4/packages/vizservers/vtkvis/CmdProc.cpp

    r2550 r2681  
    1010
    1111#include "CmdProc.h"
     12
     13using namespace Rappture;
    1214
    1315/**
     
    2224 */
    2325static int
    24 BinaryOpSearch(Rappture::CmdSpec *specs,
     26BinaryOpSearch(CmdSpec *specs,
    2527               int nSpecs,
    2628               char *string)       /* Name of minor operation to search for */
     
    3537    length = strlen(string);
    3638    while (low <= high) {
    37         Rappture::CmdSpec *specPtr;
     39        CmdSpec *specPtr;
    3840        int compare;
    3941        int median;
     
    7678 */
    7779static int
    78 LinearOpSearch(Rappture::CmdSpec *specs,
     80LinearOpSearch(CmdSpec *specs,
    7981               int nSpecs,
    8082               char *string)       /* Name of minor operation to search for */
    8183{
    82     Rappture::CmdSpec *specPtr;
     84    CmdSpec *specPtr;
    8385    char c;
    8486    size_t length;
     
    120122 */
    121123Tcl_ObjCmdProc *
    122 Rappture::GetOpFromObj(Tcl_Interp *interp,              /* Interpreter to report errors to */
    123                        int nSpecs,                      /* Number of specifications in array */
    124                        Rappture::CmdSpec *specs,        /* Op specification array */
    125                        int operPos,                     /* Position of operation in argument
    126                                                          * list. */
    127                        int objc,                        /* Number of arguments in the argument
    128                                                          * vector.  This includes any prefixed
    129                                                          * arguments */
    130                        Tcl_Obj *const *objv,            /* Argument vector */
     124Rappture::GetOpFromObj(Tcl_Interp *interp,      /* Interpreter to report errors to */
     125                       int nSpecs,              /* Number of specifications in array */
     126                       CmdSpec *specs,          /* Op specification array */
     127                       int operPos,             /* Position of operation in argument
     128                                                 * list. */
     129                       int objc,                /* Number of arguments in the argument
     130                                                 * vector.  This includes any prefixed
     131                                                 * arguments */
     132                       Tcl_Obj *const *objv,    /* Argument vector */
    131133                       int flags)
    132134{
  • branches/blt4/packages/vizservers/vtkvis/CmdProc.h

    r2550 r2681  
    1919 * for a function pointer associated with the operation name.
    2020 */
    21 typedef struct {
     21struct CmdSpec {
    2222    const char *name;           /**< Name of operation */
    2323    int minChars;               /**< Minimum # characters to disambiguate */
     
    2626    int maxArgs;                /**< Maximum # args required */
    2727    const char *usage;          /**< Usage message */
    28 } CmdSpec;
     28};
    2929
    30 typedef enum {
     30enum CmdSpecIndex {
    3131    CMDSPEC_ARG0,               /**< Op is the first argument. */
    3232    CMDSPEC_ARG1,               /**< Op is the second argument. */
     
    3434    CMDSPEC_ARG3,               /**< Op is the fourth argument. */
    3535    CMDSPEC_ARG4                /**< Op is the fifth argument. */
    36 } CmdSpecIndex;
     36};
    3737
    3838#define CMDSPEC_LINEAR_SEARCH   1
  • branches/blt4/packages/vizservers/vtkvis/ColorMap.cpp

    r2542 r2681  
    106106        cp.value = 1.0;
    107107
     108#ifdef DEBUG
    108109    TRACE("New control point: %g  = %g %g %g",
    109110          cp.value, cp.color[0], cp.color[1], cp.color[2]);
    110 
     111#endif
    111112    for (std::list<ControlPoint>::iterator itr = _controlPoints.begin();
    112113         itr != _controlPoints.end(); ++itr) {
     
    136137        cp.value = 1.0;
    137138
     139#ifdef DEBUG
    138140    TRACE("New opacity control point: %g  = %g",
    139141          cp.value, cp.alpha);
    140 
     142#endif
    141143    for (std::list<OpacityControlPoint>::iterator itr = _opacityControlPoints.begin();
    142144         itr != _opacityControlPoints.end(); ++itr) {
  • branches/blt4/packages/vizservers/vtkvis/Makefile.in

    r2550 r2681  
    2424
    2525GL_LIB_SPEC     = -lGL -lm
     26PTHREAD_LIB_SPEC= -lpthread
    2627
    2728TCL_LIB_SPEC    = @TCL_LIB_SPEC@
     
    3536
    3637LIBS            = \
    37                 $(GL_LIB_SPEC) \
    3838                $(TCL_LIB_SPEC) \
    3939                $(VTK_LIB_SPEC) \
     40                $(GL_LIB_SPEC) \
     41                $(PTHREAD_LIB_SPEC) \
    4042                -Wl,-rpath,$(LD_RUN_PATH)
    4143
     
    4951USE_CUSTOM_AXES         = yes
    5052USE_GPU_RAYCASTING      = yes
    51 USE_OFFSCREEN_RENDERING = yes
     53USE_OFFSCREEN_RENDERING = #yes
     54USE_THREADS             = yes
    5255
    5356#vtk uses deprecated strstream header (instead of sstream)
     
    7073DEFINES         += -DUSE_GPU_RAYCAST_MAPPER
    7174endif
     75ifdef USE_THREADS
     76DEFINES         += -DUSE_THREADS
     77endif
    7278CXX_SWITCHES    = $(CXXFLAGS) $(EXTRA_CFLAGS) $(DEFINES) $(INCLUDES)
    7379
     
    7682                ColorMap.cpp \
    7783                PPMWriter.cpp \
     84                ReadBuffer.cpp \
    7885                RpContour2D.cpp \
    7986                RpContour3D.cpp \
     
    8895                RpVolume.cpp \
    8996                RpVtkDataSet.cpp \
    90                 RpVtkRenderer.cpp\
     97                RpVtkGraphicsObject.cpp \
     98                RpVtkRenderer.cpp \
    9199                RpVtkRendererCmd.cpp \
     100                RpVtkRendererGraphicsObjs.cpp \
    92101                RpVtkRenderServer.cpp \
    93102                TGAWriter.cpp \
     
    96105ifdef USE_CUSTOM_AXES
    97106SERVER_SRCS+=vtkRpCubeAxesActor2D.cpp
     107endif
     108ifdef USE_THREADS
     109SERVER_SRCS+=ResponseQueue.cpp
    98110endif
    99111
     
    130142CmdProc.o: CmdProc.h
    131143ColorMap.o: ColorMap.h RpMolecule.h Trace.h
    132 PPMWriter.o: PPMWriter.h Trace.h
    133 RpContour2D.o: RpContour2D.h RpVtkGraphicsObject.h RpVtkDataSet.h Trace.h
    134 RpContour3D.o: RpContour3D.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    135 RpCutplane.o: RpCutplane.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    136 RpGlyphs.o: RpGlyphs.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    137 RpHeightMap.o: RpHeightMap.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    138 RpLIC.o: RpLIC.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h RpVtkRenderServer.h
    139 RpMolecule.o: RpMolecule.h RpMoleculeData.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    140 RpPolyData.o: RpPolyData.h RpVtkGraphicsObject.h RpVtkDataSet.h Trace.h
    141 RpPseudoColor.o: RpPseudoColor.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    142 RpStreamlines.o: RpStreamlines.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
    143 RpVolume.o: RpVolume.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
     144PPMWriter.o: PPMWriter.h ResponseQueue.h Trace.h
     145ReadBuffer.o: ReadBuffer.h Trace.h
     146ResponseQueue.o: ResponseQueue.h Trace.h
     147RpContour2D.o: RpContour2D.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h Trace.h
     148RpContour3D.o: RpContour3D.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     149RpCutplane.o: RpCutplane.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     150RpGlyphs.o: RpGlyphs.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     151RpHeightMap.o: RpHeightMap.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     152RpLIC.o: RpLIC.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h RpVtkRenderServer.h
     153RpMolecule.o: RpMolecule.h RpMoleculeData.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     154RpPolyData.o: RpPolyData.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h Trace.h
     155RpPseudoColor.o: RpPseudoColor.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     156RpStreamlines.o: RpStreamlines.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
     157RpVolume.o: RpVolume.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
    144158RpVtkDataSet.o: RpVtkDataSet.h Trace.h
    145 RpVtkRenderer.o: RpVtkRenderer.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
    146 RpVtkRendererCmd.o: RpVtkRenderer.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
    147 RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor2D.h Trace.h PPMWriter.h TGAWriter.h
     159RpVtkGraphicsObject.o: RpVtkGraphicsObject.h RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
     160RpVtkRenderer.o: RpVtkRenderer.h RpMath.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
     161RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
     162RpVtkRendererGraphicsObjs.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
     163RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor2D.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
    148164Trace.o: Trace.h
    149 TGAWriter.o: TGAWriter.h Trace.h
     165TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h
    150166vtkRpCubeAxesActor2D.o: vtkRpCubeAxesActor2D.h
  • branches/blt4/packages/vizservers/vtkvis/PPMWriter.cpp

    r2550 r2681  
    1212#include <sys/uio.h>
    1313
     14#include "Trace.h"
    1415#include "PPMWriter.h"
    15 #include "Trace.h"
     16#ifdef USE_THREADS
     17#include "ResponseQueue.h"
     18#endif
    1619
    1720using namespace Rappture::VtkVis;
     21
     22#ifdef USE_THREADS
     23
     24/**
     25 * \brief Writes image data as PPM binary data to the client.
     26 *
     27 * The PPM binary format is very simple.
     28 *
     29 *     P6 w h 255\n
     30 *     3-byte RGB pixel data.
     31 *
     32 * The client (using the TkImg library) will do less work to unpack this
     33 * format, as opposed to BMP or PNG.
     34 *
     35 * Note that currently the image data has bottom to top scanlines.  This
     36 * routine could be made even simpler (faster) if the image data had top
     37 * to bottom scanlines.
     38 *
     39 * \param[in] queue Pointer to ResponseQueue to write to
     40 * \param[in] cmdName Command name to send (byte length will be appended)
     41 * \param[in] data Image data
     42 * \param[in] width Width of image in pixels
     43 * \param[in] height Height of image in pixels
     44 */
     45void
     46Rappture::VtkVis::queuePPM(ResponseQueue *queue, const char *cmdName,
     47                           const unsigned char *data, int width, int height)
     48{
     49#define PPM_MAXVAL 255
     50    char header[200];
     51
     52    TRACE("Entering (%dx%d)\n", width, height);
     53    // Generate the PPM binary file header
     54    snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height,
     55             PPM_MAXVAL);
     56
     57    size_t headerLength = strlen(header);
     58    size_t dataLength = width * height * 3;
     59
     60    char command[200];
     61    snprintf(command, sizeof(command), "%s %lu\n", cmdName,
     62             (unsigned long)headerLength + dataLength);
     63
     64    size_t cmdLength;
     65    cmdLength = strlen(command);
     66
     67    size_t length;
     68    unsigned char *mesg;
     69
     70    length = headerLength + dataLength + cmdLength;
     71    mesg = (unsigned char *)malloc(length);
     72    if (mesg == NULL) {
     73        ERROR("can't allocate %ld bytes for the image message", length);
     74        return;
     75    }
     76    memcpy(mesg, command, cmdLength);
     77    memcpy(mesg + cmdLength, header, headerLength);
     78
     79    size_t bytesPerRow = width * 3;
     80    unsigned char *destRowPtr = mesg + length - bytesPerRow;
     81    int y;
     82    unsigned char *srcRowPtr = const_cast<unsigned char *>(data);
     83    for (y = 0; y < height; y++) {
     84        memcpy(destRowPtr, srcRowPtr, bytesPerRow);
     85        srcRowPtr += bytesPerRow;
     86        destRowPtr -= bytesPerRow;
     87    }
     88
     89    Response *response;
     90    if (strncmp(cmdName, "nv>legend", 9) == 0) {
     91        response = new Response(Response::LEGEND);
     92    } else {
     93        response = new Response(Response::IMAGE);
     94    }
     95    response->setMessage(mesg, length, Response::DYNAMIC);
     96    queue->enqueue(response);
     97    TRACE("Leaving (%dx%d)\n", width, height);
     98}
     99#else
    18100
    19101/**
     
    39121 */
    40122void
    41 Rappture::VtkVis::writePPM(int fd, const char *cmdName, const unsigned char *data,
    42                            int width, int height)
     123Rappture::VtkVis::writePPM(int fd, const char *cmdName,
     124                           const unsigned char *data, int width, int height)
    43125{
    44126#define PPM_MAXVAL 255
     
    47129    TRACE("Entering (%dx%d)\n", width, height);
    48130    // Generate the PPM binary file header
    49     snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height, PPM_MAXVAL);
     131    snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height,
     132             PPM_MAXVAL);
    50133
    51134    size_t headerLength = strlen(header);
     
    79162    }
    80163    if (writev(fd, iov, nRecs) < 0) {
    81         ERROR("write failed: %s\n", strerror(errno));
     164        ERROR("write failed: %s\n", strerror(errno));
    82165    }
    83166    free(iov);
     
    85168    TRACE("Leaving (%dx%d)\n", width, height);
    86169}
     170
     171#endif /*USE_THREADS*/
  • branches/blt4/packages/vizservers/vtkvis/PPMWriter.h

    r2550 r2681  
    99#define __RAPPTURE_VTKVIS_PPMWRITER_H__
    1010
     11#ifdef USE_THREADS
     12#include "ResponseQueue.h"
     13#endif
     14
    1115namespace Rappture {
    1216namespace VtkVis {
    13 
     17#ifdef USE_THREADS
    1418extern
    15 void writePPM(int fd, const char *cmdName, const unsigned char *data, int width, int height);
    16 
     19void queuePPM(ResponseQueue *queue, const char *cmdName,
     20              const unsigned char *data, int width, int height);
     21#else
     22extern
     23void writePPM(int fd, const char *cmdName,
     24              const unsigned char *data, int width, int height);
     25#endif
    1726}
    1827}
    19 
    2028#endif
  • branches/blt4/packages/vizservers/vtkvis/ResponseQueue.cpp

    r2543 r2681  
    2929ResponseQueue::~ResponseQueue()
    3030{
     31    TRACE("Deleting ResponseQueue");
    3132    pthread_mutex_destroy(&_idle);
    3233    if (sem_destroy(&_ready) < 0) {
    3334        ERROR("can't destroy semaphore: %s", strerror(errno));
    3435    }
     36    for (std::list<Response *>::iterator itr = _list.begin();
     37         itr != _list.end(); ++itr) {
     38        delete *itr;
     39    }
     40    _list.clear();
    3541}
    3642
     
    6470ResponseQueue::dequeue()
    6571{
    66     Response *response;
     72    Response *response = NULL;
    6773
    6874    if (sem_wait(&_ready) < 0) {
     
    7177    if (pthread_mutex_lock(&_idle) != 0) {
    7278        ERROR("can't lock mutex: %s", strerror(errno));
    73     }   
    74     response = _list.front();
    75     _list.pop_front();
     79    }
     80    if (_list.empty()) {
     81        ERROR("Empty queue");
     82    } else {
     83        response = _list.front();
     84        _list.pop_front();
     85    }
    7686    if (pthread_mutex_unlock(&_idle) != 0) {
    7787        ERROR("can't unlock mutex: %s", strerror(errno));
  • branches/blt4/packages/vizservers/vtkvis/ResponseQueue.h

    r2543 r2681  
    1717namespace VtkVis {
    1818
     19/**
     20 * \brief Holds data for a response to be sent to client
     21 */
    1922class Response
    2023{
     
    4043    virtual ~Response()
    4144    {
    42         if (_length > 0) {
    43             if (_allocType == DYNAMIC) {
    44                 free(_mesg);
    45             }
     45        if ((_length > 0) && (_mesg != NULL) && (_allocType == DYNAMIC)) {
     46            free(_mesg);
    4647        }
    4748    }
    4849
     50    /// Get the ResponseType
    4951    ResponseType type()
    5052    {
     
    5254    }
    5355
     56    /// Get the Response data
    5457    unsigned char *message()
    5558    {
     
    5760    }
    5861
     62    /// Get the number of bytes in the Response data
    5963    size_t length()
    6064    {
     
    6266    }
    6367
     68    /// Set the message/data making up the Response
     69    /**
     70     * If the AllocationType is DYNAMIC, the message data will be free()d
     71     * by the destructor.  If the AllocationType is VOLATILE, a copy of
     72     * the message data will be made.
     73     *
     74     * \param[in] mesg The Response data, can be a command and/or binary data
     75     * \param[in] length The number of bytes in mesg
     76     * \param[in] type Specify how the memory was allocated for mesg
     77     */
    6478    void setMessage(unsigned char *mesg, size_t length, AllocationType type)
    6579    {
     
    86100};
    87101
     102/**
     103 * \brief Queue to hold pending Responses to be sent to the client
     104 *
     105 * A semaphore and mutex are used to control access to the
     106 * queue by a reader and writer thread
     107 */
    88108class ResponseQueue
    89109{
     
    93113    virtual ~ResponseQueue();
    94114
     115    /// A place to store a data pointer.  Not used internally.
     116    /* XXX: This probably doesn't belong here */
    95117    void *clientData()
    96118    {
     
    98120    }
    99121
     122    /// Add a response to the end of the queue
    100123    void enqueue(Response *response);
    101124
     125    /// Remove a response from the front of the queue
    102126    Response *dequeue();
    103127
  • branches/blt4/packages/vizservers/vtkvis/RpContour2D.cpp

    r2542 r2681  
    100100            pd->GetNumberOfStrips() == 0) {
    101101            // DataSet is a point cloud
    102             DataSet::PrincipalPlane plane;
     102            PrincipalPlane plane;
    103103            double offset;
    104104            if (_dataSet->is2D(&plane, &offset)) {
    105105                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    106                 if (plane == DataSet::PLANE_ZY) {
     106                if (plane == PLANE_ZY) {
    107107                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    108108                    trans->RotateWXYZ(90, 0, 1, 0);
     
    111111                    }
    112112                    mesher->SetTransform(trans);
    113                 } else if (plane == DataSet::PLANE_XZ) {
     113                } else if (plane == PLANE_XZ) {
    114114                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    115115                    trans->RotateWXYZ(-90, 1, 0, 0);
     
    179179}
    180180
    181 void Contour2D::updateRanges(bool useCumulative,
    182                              double scalarRange[2],
    183                              double vectorMagnitudeRange[2],
    184                              double vectorComponentRange[3][2])
    185 {
    186     if (useCumulative) {
    187         _dataRange[0] = scalarRange[0];
    188         _dataRange[1] = scalarRange[1];
    189     } else if (_dataSet != NULL) {
    190         _dataSet->getScalarRange(_dataRange);
    191     } else {
    192         WARN("updateRanges called before setDataSet");
    193     }
    194 
     181void Contour2D::updateRanges(Renderer *renderer)
     182{
     183    VtkGraphicsObject::updateRanges(renderer);
     184 
    195185    if (_contours.empty() && _numContours > 0) {
    196186        // Contour isovalues need to be recomputed
  • branches/blt4/packages/vizservers/vtkvis/RpContour2D.h

    r2542 r2681  
    4848    const std::vector<double>& getContourList() const;
    4949
    50     virtual void updateRanges(bool useCumulative,
    51                               double scalarRange[2],
    52                               double vectorMagnitudeRange[2],
    53                               double vectorComponentRange[3][2]);
     50    virtual void updateRanges(Renderer *renderer);
    5451
    5552    virtual void setColor(float color[3])
  • branches/blt4/packages/vizservers/vtkvis/RpContour3D.cpp

    r2550 r2681  
    186186}
    187187
    188 void Contour3D::updateRanges(bool useCumulative,
    189                              double scalarRange[2],
    190                              double vectorMagnitudeRange[2],
    191                              double vectorComponentRange[3][2])
    192 {
    193     if (useCumulative) {
    194         _dataRange[0] = scalarRange[0];
    195         _dataRange[1] = scalarRange[1];
    196     } else if (_dataSet != NULL) {
    197         _dataSet->getScalarRange(_dataRange);
    198     }
     188void Contour3D::updateRanges(Renderer *renderer)
     189{
     190    VtkGraphicsObject::updateRanges(renderer);
    199191
    200192    if (_lut != NULL) {
  • branches/blt4/packages/vizservers/vtkvis/RpContour3D.h

    r2542 r2681  
    6262    void updateColorMap();
    6363
    64     virtual void updateRanges(bool useCumulative,
    65                               double scalarRange[2],
    66                               double vectorMagnitudeRange[2],
    67                               double vectorComponentRange[3][2]);
     64    virtual void updateRanges(Renderer *renderer);
    6865
    6966private:
  • branches/blt4/packages/vizservers/vtkvis/RpCutplane.cpp

    r2550 r2681  
    77
    88#include <cassert>
     9#include <cfloat>
     10#include <cstring>
    911
    1012#include <vtkDataSet.h>
     
    2527
    2628#include "RpCutplane.h"
     29#include "RpVtkRenderer.h"
    2730#include "Trace.h"
    2831
     
    3336Cutplane::Cutplane() :
    3437    VtkGraphicsObject(),
     38    _colorMap(NULL),
    3539    _colorMode(COLOR_BY_SCALAR),
    36     _colorMap(NULL),
    37     _sliceAxis(Z_AXIS)
    38 {
     40    _colorFieldType(DataSet::POINT_DATA),
     41    _renderer(NULL)
     42{
     43    _colorFieldRange[0] = DBL_MAX;
     44    _colorFieldRange[1] = -DBL_MAX;
    3945}
    4046
     
    5056
    5157void Cutplane::setDataSet(DataSet *dataSet,
    52                           bool useCumulative,
    53                           double scalarRange[2],
    54                           double vectorMagnitudeRange[2],
    55                           double vectorComponentRange[3][2])
     58                          Renderer *renderer)
    5659{
    5760    if (_dataSet != dataSet) {
    5861        _dataSet = dataSet;
    5962
    60         if (useCumulative) {
    61             _dataRange[0] = scalarRange[0];
    62             _dataRange[1] = scalarRange[1];
    63             _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    64             _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
    65             for (int i = 0; i < 3; i++) {
    66                 _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    67                 _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     63        _renderer = renderer;
     64
     65        if (renderer->getUseCumulativeRange()) {
     66            renderer->getCumulativeDataRange(_dataRange,
     67                                             _dataSet->getActiveScalarsName(),
     68                                             1);
     69            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     70                                             _dataSet->getActiveVectorsName(),
     71                                             3);
     72            for (int i = 0; i < 3; i++) {
     73                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     74                                                 _dataSet->getActiveVectorsName(),
     75                                                 3, i);
    6876            }
    6977        } else {
     
    7987}
    8088
     89/**
     90 * \brief Create and initialize a VTK Prop to render the object
     91 */
     92void Cutplane::initProp()
     93{
     94    if (_prop == NULL) {
     95        _prop = vtkSmartPointer<vtkAssembly>::New();
     96
     97        for (int i = 0; i < 3; i++) {
     98            _actor[i] = vtkSmartPointer<vtkActor>::New();
     99            //_actor[i]->VisibilityOff();
     100            vtkProperty *property = _actor[i]->GetProperty();
     101            property->SetColor(_color[0], _color[1], _color[2]);
     102            property->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
     103            property->SetLineWidth(_edgeWidth);
     104            property->SetPointSize(_pointSize);
     105            property->EdgeVisibilityOff();
     106            property->SetOpacity(_opacity);
     107            property->SetAmbient(.2);
     108            if (!_lighting)
     109                property->LightingOff();
     110            if (_faceCulling && _opacity == 1.0) {
     111                setCulling(property, true);
     112            }
     113            getAssembly()->AddPart(_actor[i]);
     114        }
     115    }
     116}
     117
    81118void Cutplane::update()
    82119{
     
    86123    vtkDataSet *ds = _dataSet->getVtkDataSet();
    87124
     125    double bounds[6];
     126    _dataSet->getBounds(bounds);
    88127    // Mapper, actor to render color-mapped data set
    89     if (_mapper == NULL) {
    90         _mapper = vtkSmartPointer<vtkDataSetMapper>::New();
    91         // Map scalars through lookup table regardless of type
    92         _mapper->SetColorModeToMapScalars();
    93         //_mapper->InterpolateScalarsBeforeMappingOn();
    94     }
     128    for (int i = 0; i < 3; i++) {
     129        if (_mapper[i] == NULL) {
     130            _mapper[i] = vtkSmartPointer<vtkDataSetMapper>::New();
     131            // Map scalars through lookup table regardless of type
     132            _mapper[i]->SetColorModeToMapScalars();
     133            //_mapper->InterpolateScalarsBeforeMappingOn();
     134        }
     135        _cutPlane[i] = vtkSmartPointer<vtkPlane>::New();
     136        switch (i) {
     137        case 0:
     138            _cutPlane[i]->SetNormal(1, 0, 0);
     139            _cutPlane[i]->SetOrigin(bounds[0] + (bounds[1]-bounds[0])/2.,
     140                                    0,
     141                                    0);
     142            break;
     143        case 1:
     144            _cutPlane[i]->SetNormal(0, 1, 0);
     145            _cutPlane[i]->SetOrigin(0,
     146                                    bounds[2] + (bounds[3]-bounds[2])/2.,
     147                                    0);
     148            break;
     149        case 2:
     150        default:
     151            _cutPlane[i]->SetNormal(0, 0, 1);
     152            _cutPlane[i]->SetOrigin(0,
     153                                    0,
     154                                    bounds[4] + (bounds[5]-bounds[4])/2.);
     155            break;
     156        }
     157        _cutter[i] = vtkSmartPointer<vtkCutter>::New();
     158        _cutter[i]->SetCutFunction(_cutPlane[i]);
     159    }
     160
     161    initProp();
    95162
    96163    vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
    97     if (pd) {
    98         // DataSet is a vtkPolyData
    99         if (pd->GetNumberOfLines() == 0 &&
    100             pd->GetNumberOfPolys() == 0 &&
    101             pd->GetNumberOfStrips() == 0) {
    102             // DataSet is a point cloud
    103             DataSet::PrincipalPlane plane;
    104             double offset;
    105             if (_dataSet->is2D(&plane, &offset)) {
    106                 // DataSet is a 2D point cloud
     164    if (pd &&
     165        pd->GetNumberOfLines() == 0 &&
     166        pd->GetNumberOfPolys() == 0 &&
     167        pd->GetNumberOfStrips() == 0) {
     168        // DataSet is a point cloud
     169        PrincipalPlane plane;
     170        double offset;
     171        if (_dataSet->is2D(&plane, &offset)) {
     172            // DataSet is a 2D point cloud
    107173#ifdef MESH_POINT_CLOUDS
    108                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    109                 if (plane == DataSet::PLANE_ZY) {
    110                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    111                     trans->RotateWXYZ(90, 0, 1, 0);
    112                     if (offset != 0.0) {
    113                         trans->Translate(-offset, 0, 0);
    114                     }
    115                     mesher->SetTransform(trans);
    116                     _sliceAxis = X_AXIS;
    117                 } else if (plane == DataSet::PLANE_XZ) {
    118                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    119                     trans->RotateWXYZ(-90, 1, 0, 0);
    120                     if (offset != 0.0) {
    121                         trans->Translate(0, -offset, 0);
    122                     }
    123                     mesher->SetTransform(trans);
    124                     _sliceAxis = Y_AXIS;
    125                 } else if (offset != 0.0) {
    126                     // XY with Z offset
    127                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    128                     trans->Translate(0, 0, -offset);
    129                     mesher->SetTransform(trans);
     174            vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
     175            if (plane == PLANE_ZY) {
     176                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     177                trans->RotateWXYZ(90, 0, 1, 0);
     178                if (offset != 0.0) {
     179                    trans->Translate(-offset, 0, 0);
    130180                }
    131                 mesher->SetInput(pd);
    132                 _mapper->SetInputConnection(mesher->GetOutputPort());
     181                mesher->SetTransform(trans);
     182                _actor[1]->VisibilityOff();
     183                _actor[2]->VisibilityOff();
     184            } else if (plane == PLANE_XZ) {
     185                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     186                trans->RotateWXYZ(-90, 1, 0, 0);
     187                if (offset != 0.0) {
     188                    trans->Translate(0, -offset, 0);
     189                }
     190                mesher->SetTransform(trans);
     191                _actor[0]->VisibilityOff();
     192                _actor[2]->VisibilityOff();
     193            } else if (offset != 0.0) {
     194                // XY with Z offset
     195                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
     196                trans->Translate(0, 0, -offset);
     197                mesher->SetTransform(trans);
     198                _actor[0]->VisibilityOff();
     199                _actor[1]->VisibilityOff();
     200            }
     201            mesher->SetInput(pd);
     202            for (int i = 0; i < 3; i++) {
     203                _mapper[i]->SetInputConnection(mesher->GetOutputPort());
     204            }
    133205#else
    134                 vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    135                 splatter->SetInput(pd);
    136                 int dims[3];
    137                 splatter->GetSampleDimensions(dims);
    138                 TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
     206            vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     207            splatter->SetInput(pd);
     208            int dims[3];
     209            splatter->GetSampleDimensions(dims);
     210            TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
     211            if (plane == DataSet::PLANE_ZY) {
     212                dims[0] = 3;
     213            } else if (plane == DataSet::PLANE_XZ) {
     214                dims[1] = 3;
     215            } else {
    139216                dims[2] = 3;
    140                 splatter->SetSampleDimensions(dims);
    141                 double bounds[6];
    142                 splatter->Update();
    143                 splatter->GetModelBounds(bounds);
    144                 TRACE("Model bounds: %g %g %g %g %g %g",
    145                       bounds[0], bounds[1],
    146                       bounds[2], bounds[3],
    147                       bounds[4], bounds[5]);
    148                 vtkSmartPointer<vtkExtractVOI> slicer = vtkSmartPointer<vtkExtractVOI>::New();
    149                 slicer->SetInputConnection(splatter->GetOutputPort());
    150                 slicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, 1, 1);
    151                 slicer->SetSampleRate(1, 1, 1);
     217            }
     218            splatter->SetSampleDimensions(dims);
     219            for (int i = 0; i < 3; i++) {
     220                _cutter[i]->SetInputConnection(splatter->GetOutputPort());
    152221                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    153222                gf->UseStripsOn();
    154                 gf->SetInputConnection(slicer->GetOutputPort());
    155                 _mapper->SetInputConnection(gf->GetOutputPort());
     223                gf->SetInputConnection(_cutter[i]->GetOutputPort());
     224                _mapper[i]->SetInputConnection(gf->GetOutputPort());
     225            }
    156226#endif
    157             } else {
     227        } else {
    158228#ifdef MESH_POINT_CLOUDS
    159                 // Data Set is a 3D point cloud
    160                 // Result of Delaunay3D mesher is unstructured grid
    161                 vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
    162                 mesher->SetInput(pd);
    163                 // Run the mesher
    164                 mesher->Update();
    165                 // Get bounds of resulting grid
    166                 double bounds[6];
    167                 mesher->GetOutput()->GetBounds(bounds);
    168                 // Sample a plane within the grid bounding box
    169                 vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
    170                 cutter->SetInputConnection(mesher->GetOutputPort());
    171                 if (_cutPlane == NULL) {
    172                     _cutPlane = vtkSmartPointer<vtkPlane>::New();
    173                 }
    174                 _cutPlane->SetNormal(0, 0, 1);
    175                 _cutPlane->SetOrigin(0,
    176                                      0,
    177                                      bounds[4] + (bounds[5]-bounds[4])/2.);
    178                 cutter->SetCutFunction(_cutPlane);
     229            // Data Set is a 3D point cloud
     230            // Result of Delaunay3D mesher is unstructured grid
     231            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
     232            mesher->SetInput(pd);
     233            // Sample a plane within the grid bounding box
     234            for (int i = 0; i < 3; i++) {
     235                _cutter[i]->SetInputConnection(mesher->GetOutputPort());
    179236                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    180237                gf->UseStripsOn();
    181                 gf->SetInputConnection(cutter->GetOutputPort());
     238                gf->SetInputConnection(_cutter[i]->GetOutputPort());
     239                _mapper[i]->SetInputConnection(gf->GetOutputPort());
     240            }
    182241#else
    183                 if (_pointSplatter == NULL)
    184                     _pointSplatter = vtkSmartPointer<vtkGaussianSplatter>::New();
    185                 _pointSplatter->SetInput(pd);
    186                 int dims[3];
    187                 _pointSplatter->GetSampleDimensions(dims);
    188                 TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
    189                 dims[2] = 3;
    190                 _pointSplatter->SetSampleDimensions(dims);
    191                 double bounds[6];
    192                 _pointSplatter->Update();
    193                 _pointSplatter->GetModelBounds(bounds);
    194                 TRACE("Model bounds: %g %g %g %g %g %g",
    195                       bounds[0], bounds[1],
    196                       bounds[2], bounds[3],
    197                       bounds[4], bounds[5]);
    198                 if (_volumeSlicer == NULL)
    199                     _volumeSlicer = vtkSmartPointer<vtkExtractVOI>::New();
    200                 _volumeSlicer->SetInputConnection(_pointSplatter->GetOutputPort());
    201                 _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, 1, 1);
    202                 _volumeSlicer->SetSampleRate(1, 1, 1);
     242            vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
     243            splatter->SetInput(pd);
     244            int dims[3];
     245            splatter->GetSampleDimensions(dims);
     246            TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
     247            for (int i = 0; i < 3; i++) {
     248                _cutter[i]->SetInputConnection(splatter->GetOutputPort());
    203249                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    204250                gf->UseStripsOn();
    205                 gf->SetInputConnection(_volumeSlicer->GetOutputPort());
     251                gf->SetInputConnection(_cutter[i]->GetOutputPort());
     252                _mapper[i]->SetInputConnection(gf->GetOutputPort());
     253            }
    206254#endif
    207                 _mapper->SetInputConnection(gf->GetOutputPort());
    208              }
    209         } else {
    210             // DataSet is a vtkPolyData with lines and/or polygons
    211             _mapper->SetInput(ds);
    212255        }
    213256    } else {
    214         // DataSet is NOT a vtkPolyData
    215         // Can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid
    216         vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
    217         gf->UseStripsOn();
    218         vtkImageData *imageData = vtkImageData::SafeDownCast(ds);
    219         if (!_dataSet->is2D() && imageData != NULL) {
    220             // 3D image/volume/uniform grid
    221             if (_volumeSlicer == NULL)
    222                 _volumeSlicer = vtkSmartPointer<vtkExtractVOI>::New();
    223             int dims[3];
    224             imageData->GetDimensions(dims);
    225             TRACE("Image data dimensions: %d %d %d", dims[0], dims[1], dims[2]);
    226             _volumeSlicer->SetInput(ds);
    227             _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, (dims[2]-1)/2, (dims[2]-1)/2);
    228             _volumeSlicer->SetSampleRate(1, 1, 1);
    229             gf->SetInputConnection(_volumeSlicer->GetOutputPort());
    230         } else if (!_dataSet->is2D() && imageData == NULL) {
    231             // 3D structured grid, unstructured grid, or rectilinear grid
    232             double bounds[6];
    233             ds->GetBounds(bounds);
     257        // DataSet can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid, or
     258        // PolyData with cells other than points
     259        PrincipalPlane plane;
     260        double offset;
     261        if (!_dataSet->is2D(&plane, &offset)) {
    234262            // Sample a plane within the grid bounding box
    235             vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
    236             cutter->SetInput(ds);
    237             if (_cutPlane == NULL) {
    238                 _cutPlane = vtkSmartPointer<vtkPlane>::New();
    239             }
    240             _cutPlane->SetNormal(0, 0, 1);
    241             _cutPlane->SetOrigin(0,
    242                                  0,
    243                                  bounds[4] + (bounds[5]-bounds[4])/2.);
    244             cutter->SetCutFunction(_cutPlane);
    245             gf->SetInputConnection(cutter->GetOutputPort());
     263            for (int i = 0; i < 3; i++) {
     264                _cutter[i]->SetInput(ds);
     265                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     266                gf->UseStripsOn();
     267                gf->SetInputConnection(_cutter[i]->GetOutputPort());
     268                _mapper[i]->SetInputConnection(gf->GetOutputPort());
     269            }
    246270        } else {
    247271            // 2D data
    248             gf->SetInput(ds);
    249         }
    250         _mapper->SetInputConnection(gf->GetOutputPort());
     272            if (plane == PLANE_ZY) {
     273                _actor[1]->VisibilityOff();
     274                _actor[2]->VisibilityOff();
     275            } else if (plane == PLANE_XZ) {
     276                _actor[0]->VisibilityOff();
     277                _actor[2]->VisibilityOff();
     278            } else if (offset != 0.0) {
     279                // XY with Z offset
     280                _actor[0]->VisibilityOff();
     281                _actor[1]->VisibilityOff();
     282            }
     283            for (int i = 0; i < 3; i++) {
     284                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
     285                gf->UseStripsOn();
     286                gf->SetInput(ds);
     287                _mapper[i]->SetInputConnection(gf->GetOutputPort());
     288            }
     289        }
    251290    }
    252291
     
    255294    }
    256295
    257     initProp();
    258     getActor()->SetMapper(_mapper);
    259     _mapper->Update();
    260 }
    261 
     296    setColorMode(_colorMode);
     297
     298    for (int i = 0; i < 3; i++) {
     299        if (_mapper[i] != NULL) {
     300            _actor[i]->SetMapper(_mapper[i]);
     301            _mapper[i]->Update();
     302        }
     303    }
     304}
    262305
    263306/**
     
    274317    }
    275318
    276     if (_volumeSlicer == NULL &&
    277         _cutPlane == NULL) {
     319    if ((axis == X_AXIS &&_cutPlane[0] == NULL) ||
     320        (axis == Y_AXIS &&_cutPlane[1] == NULL) ||
     321        (axis == Z_AXIS &&_cutPlane[2] == NULL)) {
    278322        WARN("Called before update() or DataSet is not a volume");
    279323        return;
    280324    }
    281325
    282     _sliceAxis = axis;
    283 
    284     if (_cutPlane != NULL) {
    285         double bounds[6];
    286         _dataSet->getBounds(bounds);
    287         switch (axis) {
    288         case X_AXIS:
    289             _cutPlane->SetNormal(1, 0, 0);
    290             _cutPlane->SetOrigin(bounds[0] + (bounds[1]-bounds[0]) * ratio,
    291                                  0,
    292                                  0);
    293             break;
    294         case Y_AXIS:
    295             _cutPlane->SetNormal(0, 1, 0);
    296             _cutPlane->SetOrigin(0,
    297                                  bounds[2] + (bounds[3]-bounds[2]) * ratio,
    298                                  0);
    299             break;
    300         case Z_AXIS:
    301             _cutPlane->SetNormal(0, 0, 1);
    302             _cutPlane->SetOrigin(0,
    303                                  0,
    304                                  bounds[4] + (bounds[5]-bounds[4]) * ratio);
    305             break;
    306         default:
    307             ERROR("Invalid Axis");
    308             return;
     326    double bounds[6];
     327    _dataSet->getBounds(bounds);
     328    switch (axis) {
     329    case X_AXIS:
     330        _cutPlane[0]->SetOrigin(bounds[0] + (bounds[1]-bounds[0]) * ratio,
     331                                0,
     332                                0);
     333        if (_mapper[0] != NULL)
     334            _mapper[0]->Update();
     335        break;
     336    case Y_AXIS:
     337        _cutPlane[1]->SetOrigin(0,
     338                                bounds[2] + (bounds[3]-bounds[2]) * ratio,
     339                                0);
     340        if (_mapper[1] != NULL)
     341            _mapper[1]->Update();
     342        break;
     343    case Z_AXIS:
     344        _cutPlane[2]->SetOrigin(0,
     345                                0,
     346                                bounds[4] + (bounds[5]-bounds[4]) * ratio);
     347        if (_mapper[2] != NULL)
     348            _mapper[2]->Update();
     349        break;
     350    default:
     351        ERROR("Invalid Axis");
     352        return;
     353    }
     354}
     355
     356void Cutplane::updateRanges(Renderer *renderer)
     357{
     358    if (_dataSet == NULL) {
     359        ERROR("called before setDataSet");
     360        return;
     361    }
     362
     363    if (renderer->getUseCumulativeRange()) {
     364        renderer->getCumulativeDataRange(_dataRange,
     365                                         _dataSet->getActiveScalarsName(),
     366                                         1);
     367        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     368                                         _dataSet->getActiveVectorsName(),
     369                                         3);
     370        for (int i = 0; i < 3; i++) {
     371            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     372                                             _dataSet->getActiveVectorsName(),
     373                                             3, i);
    309374        }
    310375    } else {
    311         int dims[3];
    312         if (_pointSplatter != NULL) {
    313             _pointSplatter->GetSampleDimensions(dims);
    314         } else {
    315             vtkImageData *imageData = vtkImageData::SafeDownCast(_dataSet->getVtkDataSet());
    316             if (imageData == NULL) {
    317                 ERROR("Not a volume data set");
    318                 return;
    319             }
    320             imageData->GetDimensions(dims);
    321         }
    322         int voi[6];
    323 
    324         switch (axis) {
    325         case X_AXIS:
    326             voi[0] = voi[1] = (int)((dims[0]-1) * ratio);
    327             voi[2] = 0;
    328             voi[3] = dims[1]-1;
    329             voi[4] = 0;
    330             voi[5] = dims[2]-1;
    331             break;
    332         case Y_AXIS:
    333             voi[0] = 0;
    334             voi[1] = dims[0]-1;
    335             voi[2] = voi[3] = (int)((dims[1]-1) * ratio);
    336             voi[4] = 0;
    337             voi[5] = dims[2]-1;
    338             break;
    339         case Z_AXIS:
    340             voi[0] = 0;
    341             voi[1] = dims[0]-1;
    342             voi[2] = 0;
    343             voi[3] = dims[1]-1;
    344             voi[4] = voi[5] = (int)((dims[2]-1) * ratio);
    345             break;
    346         default:
    347             ERROR("Invalid Axis");
    348             return;
    349         }
    350 
    351         _volumeSlicer->SetVOI(voi);
    352     }
    353 
    354     if (_mapper != NULL)
    355         _mapper->Update();
    356 }
    357 
    358 void Cutplane::updateRanges(bool useCumulative,
    359                             double scalarRange[2],
    360                             double vectorMagnitudeRange[2],
    361                             double vectorComponentRange[3][2])
    362 {
    363     if (useCumulative) {
    364         _dataRange[0] = scalarRange[0];
    365         _dataRange[1] = scalarRange[1];
    366         _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    367         _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
    368         for (int i = 0; i < 3; i++) {
    369             _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    370             _vectorComponentRange[i][1] = vectorComponentRange[i][1];
    371         }
    372     } else if (_dataSet != NULL) {
    373376        _dataSet->getScalarRange(_dataRange);
    374377        _dataSet->getVectorRange(_vectorMagnitudeRange);
     
    378381    }
    379382
    380     // Need to update color map ranges and/or active vector field
    381     setColorMode(_colorMode);
     383    // Need to update color map ranges
     384    double *rangePtr = _colorFieldRange;
     385    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     386        rangePtr = NULL;
     387    }
     388    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
    382389}
    383390
     
    385392{
    386393    _colorMode = mode;
    387     if (_dataSet == NULL || _mapper == NULL)
    388         return;
    389 
    390     vtkDataSet *ds = _dataSet->getVtkDataSet();
     394    if (_dataSet == NULL)
     395        return;
    391396
    392397    switch (mode) {
    393     case COLOR_BY_SCALAR: {
    394         _mapper->ScalarVisibilityOn();
    395         _mapper->SetScalarModeToDefault();
     398    case COLOR_BY_SCALAR:
     399        setColorMode(mode,
     400                     _dataSet->getActiveScalarsType(),
     401                     _dataSet->getActiveScalarsName(),
     402                     _dataRange);
     403        break;
     404    case COLOR_BY_VECTOR_MAGNITUDE:
     405        setColorMode(mode,
     406                     _dataSet->getActiveVectorsType(),
     407                     _dataSet->getActiveVectorsName(),
     408                     _vectorMagnitudeRange);
     409        break;
     410    case COLOR_BY_VECTOR_X:
     411        setColorMode(mode,
     412                     _dataSet->getActiveVectorsType(),
     413                     _dataSet->getActiveVectorsName(),
     414                     _vectorComponentRange[0]);
     415        break;
     416    case COLOR_BY_VECTOR_Y:
     417        setColorMode(mode,
     418                     _dataSet->getActiveVectorsType(),
     419                     _dataSet->getActiveVectorsName(),
     420                     _vectorComponentRange[1]);
     421        break;
     422    case COLOR_BY_VECTOR_Z:
     423        setColorMode(mode,
     424                     _dataSet->getActiveVectorsType(),
     425                     _dataSet->getActiveVectorsName(),
     426                     _vectorComponentRange[2]);
     427        break;
     428    default:
     429        ;
     430    }
     431}
     432
     433void Cutplane::setColorMode(ColorMode mode,
     434                            const char *name, double range[2])
     435{
     436    if (_dataSet == NULL)
     437        return;
     438    DataSet::DataAttributeType type;
     439    int numComponents;
     440    if (!_dataSet->getFieldInfo(name, &type, &numComponents)) {
     441        ERROR("Field not found: %s", name);
     442        return;
     443    }
     444    setColorMode(mode, type, name, range);
     445}
     446
     447void Cutplane::setColorMode(ColorMode mode,
     448                            DataSet::DataAttributeType type,
     449                            const char *name, double range[2])
     450{
     451    _colorMode = mode;
     452    _colorFieldType = type;
     453    if (name == NULL)
     454        _colorFieldName.clear();
     455    else
     456        _colorFieldName = name;
     457    if (range == NULL) {
     458        _colorFieldRange[0] = DBL_MAX;
     459        _colorFieldRange[1] = -DBL_MAX;
     460    } else {
     461        memcpy(_colorFieldRange, range, sizeof(double)*2);
     462    }
     463
     464    if (_dataSet == NULL ||
     465        _mapper[0] == NULL ||
     466        _mapper[1] == NULL ||
     467        _mapper[2] == NULL)
     468        return;
     469
     470    switch (type) {
     471    case DataSet::POINT_DATA:
     472        for (int i = 0; i < 3; i++) {
     473            _mapper[i]->SetScalarModeToUsePointFieldData();
     474        }
     475        break;
     476    case DataSet::CELL_DATA:
     477        for (int i = 0; i < 3; i++) {
     478            _mapper[i]->SetScalarModeToUseCellFieldData();
     479        }
     480        break;
     481    default:
     482        ERROR("Unsupported DataAttributeType: %d", type);
     483        return;
     484    }
     485
     486    if (name != NULL && strlen(name) > 0) {
     487        for (int i = 0; i < 3; i++) {
     488            _mapper[i]->SelectColorArray(name);
     489        }
     490    } else {
     491        for (int i = 0; i < 3; i++) {
     492            _mapper[i]->SetScalarModeToDefault();
     493        }
     494    }
     495
     496    if (_lut != NULL) {
     497        if (range != NULL) {
     498            _lut->SetRange(range);
     499        } else if (name != NULL && strlen(name) > 0) {
     500            double r[2];
     501            int comp = -1;
     502            if (mode == COLOR_BY_VECTOR_X)
     503                comp = 0;
     504            else if (mode == COLOR_BY_VECTOR_Y)
     505                comp = 1;
     506            else if (mode == COLOR_BY_VECTOR_Z)
     507                comp = 2;
     508
     509            if (_renderer->getUseCumulativeRange()) {
     510                int numComponents;
     511                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     512                    ERROR("Field not found: %s, type: %d", name, type);
     513                    return;
     514                } else if (numComponents < comp+1) {
     515                    ERROR("Request for component %d in field with %d components",
     516                          comp, numComponents);
     517                    return;
     518                }
     519                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     520            } else {
     521                _dataSet->getDataRange(r, name, type, comp);
     522            }
     523            _lut->SetRange(r);
     524        }
     525    }
     526
     527
     528    switch (mode) {
     529    case COLOR_BY_SCALAR:
     530        for (int i = 0; i < 3; i++) {
     531            _mapper[i]->ScalarVisibilityOn();
     532        }
     533        break;
     534    case COLOR_BY_VECTOR_MAGNITUDE:
     535        for (int i = 0; i < 3; i++) {
     536            _mapper[i]->ScalarVisibilityOn();
     537        }
    396538        if (_lut != NULL) {
    397             _lut->SetRange(_dataRange);
    398         }
    399     }
    400         break;
    401     case COLOR_BY_VECTOR_MAGNITUDE: {
    402         _mapper->ScalarVisibilityOn();
    403         if (ds->GetPointData() != NULL &&
    404             ds->GetPointData()->GetVectors() != NULL) {
    405             _mapper->SetScalarModeToUsePointFieldData();
    406             _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    407         } else if (ds->GetCellData() != NULL &&
    408                    ds->GetCellData()->GetVectors() != NULL) {
    409             _mapper->SetScalarModeToUseCellFieldData();
    410             _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
     539            _lut->SetVectorModeToMagnitude();
     540        }
     541        break;
     542    case COLOR_BY_VECTOR_X:
     543        for (int i = 0; i < 3; i++) {
     544            _mapper[i]->ScalarVisibilityOn();
    411545        }
    412546        if (_lut != NULL) {
    413             _lut->SetRange(_vectorMagnitudeRange);
    414             _lut->SetVectorModeToMagnitude();
    415         }
    416     }
    417         break;
    418     case COLOR_BY_VECTOR_X:
    419         _mapper->ScalarVisibilityOn();
    420         if (ds->GetPointData() != NULL &&
    421             ds->GetPointData()->GetVectors() != NULL) {
    422             _mapper->SetScalarModeToUsePointFieldData();
    423             _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    424         } else if (ds->GetCellData() != NULL &&
    425                    ds->GetCellData()->GetVectors() != NULL) {
    426             _mapper->SetScalarModeToUseCellFieldData();
    427             _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
    428         }
    429         if (_lut != NULL) {
    430             _lut->SetRange(_vectorComponentRange[0]);
    431547            _lut->SetVectorModeToComponent();
    432548            _lut->SetVectorComponent(0);
     
    434550        break;
    435551    case COLOR_BY_VECTOR_Y:
    436         _mapper->ScalarVisibilityOn();
    437         if (ds->GetPointData() != NULL &&
    438             ds->GetPointData()->GetVectors() != NULL) {
    439             _mapper->SetScalarModeToUsePointFieldData();
    440             _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    441         } else if (ds->GetCellData() != NULL &&
    442                    ds->GetCellData()->GetVectors() != NULL) {
    443             _mapper->SetScalarModeToUseCellFieldData();
    444             _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
     552        for (int i = 0; i < 3; i++) {
     553            _mapper[i]->ScalarVisibilityOn();
    445554        }
    446555        if (_lut != NULL) {
    447             _lut->SetRange(_vectorComponentRange[1]);
    448556            _lut->SetVectorModeToComponent();
    449557            _lut->SetVectorComponent(1);
     
    451559        break;
    452560    case COLOR_BY_VECTOR_Z:
    453         _mapper->ScalarVisibilityOn();
    454         if (ds->GetPointData() != NULL &&
    455             ds->GetPointData()->GetVectors() != NULL) {
    456             _mapper->SetScalarModeToUsePointFieldData();
    457             _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    458         } else if (ds->GetCellData() != NULL &&
    459                    ds->GetCellData()->GetVectors() != NULL) {
    460             _mapper->SetScalarModeToUseCellFieldData();
    461             _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
     561        for (int i = 0; i < 3; i++) {
     562            _mapper[i]->ScalarVisibilityOn();
    462563        }
    463564        if (_lut != NULL) {
    464             _lut->SetRange(_vectorComponentRange[2]);
    465565            _lut->SetVectorModeToComponent();
    466566            _lut->SetVectorComponent(2);
     
    468568        break;
    469569    default:
    470         _mapper->ScalarVisibilityOff();
     570        for (int i = 0; i < 3; i++) {
     571            _mapper[i]->ScalarVisibilityOff();
     572        }
    471573        break;
    472574    }
     
    493595    if (_lut == NULL) {
    494596        _lut = vtkSmartPointer<vtkLookupTable>::New();
    495         if (_mapper != NULL) {
    496             _mapper->UseLookupTableScalarRangeOn();
    497             _mapper->SetLookupTable(_lut);
    498         }
    499     }
    500 
    501     _lut->DeepCopy(cmap->getLookupTable());
     597        for (int i = 0; i < 3; i++) {
     598            if (_mapper[i] != NULL) {
     599                _mapper[i]->UseLookupTableScalarRangeOn();
     600                _mapper[i]->SetLookupTable(_lut);
     601            }
     602        }
     603        _lut->DeepCopy(cmap->getLookupTable());
     604        switch (_colorMode) {
     605        case COLOR_BY_SCALAR:
     606            _lut->SetRange(_dataRange);
     607            break;
     608        case COLOR_BY_VECTOR_MAGNITUDE:
     609            _lut->SetRange(_vectorMagnitudeRange);
     610            break;
     611        case COLOR_BY_VECTOR_X:
     612            _lut->SetRange(_vectorComponentRange[0]);
     613            break;
     614        case COLOR_BY_VECTOR_Y:
     615            _lut->SetRange(_vectorComponentRange[1]);
     616            break;
     617        case COLOR_BY_VECTOR_Z:
     618            _lut->SetRange(_vectorComponentRange[2]);
     619            break;
     620        default:
     621            break;
     622        }
     623    } else {
     624        double range[2];
     625        _lut->GetTableRange(range);
     626        _lut->DeepCopy(cmap->getLookupTable());
     627        _lut->SetRange(range);
     628    }
    502629
    503630    switch (_colorMode) {
    504     case COLOR_BY_SCALAR:
    505         _lut->SetRange(_dataRange);
    506         break;
    507631    case COLOR_BY_VECTOR_MAGNITUDE:
    508632        _lut->SetVectorModeToMagnitude();
    509         _lut->SetRange(_vectorMagnitudeRange);
    510633        break;
    511634    case COLOR_BY_VECTOR_X:
    512635        _lut->SetVectorModeToComponent();
    513636        _lut->SetVectorComponent(0);
    514         _lut->SetRange(_vectorComponentRange[0]);
    515637        break;
    516638    case COLOR_BY_VECTOR_Y:
    517639        _lut->SetVectorModeToComponent();
    518640        _lut->SetVectorComponent(1);
    519         _lut->SetRange(_vectorComponentRange[1]);
    520641        break;
    521642    case COLOR_BY_VECTOR_Z:
    522643        _lut->SetVectorModeToComponent();
    523644        _lut->SetVectorComponent(2);
    524         _lut->SetRange(_vectorComponentRange[2]);
    525645        break;
    526646    default:
    527647         break;
     648    }
     649}
     650
     651/**
     652 * \brief Set visibility of cutplane on specified axis
     653 */
     654void Cutplane::setSliceVisibility(Axis axis, bool state)
     655{
     656    switch (axis) {
     657    case X_AXIS:
     658        if (_actor[0] != NULL)
     659            _actor[0]->SetVisibility((state ? 1 : 0));
     660        break;
     661    case Y_AXIS:
     662        if (_actor[1] != NULL)
     663            _actor[1]->SetVisibility((state ? 1 : 0));
     664        break;
     665    case Z_AXIS:
     666    default:
     667        if (_actor[2] != NULL)
     668            _actor[2]->SetVisibility((state ? 1 : 0));
     669        break;
    528670    }
    529671}
     
    536678void Cutplane::setClippingPlanes(vtkPlaneCollection *planes)
    537679{
    538     if (_mapper != NULL) {
    539         _mapper->SetClippingPlanes(planes);
    540     }
    541 }
     680    for (int i = 0; i < 3; i++) {
     681        if (_mapper[i] != NULL) {
     682            _mapper[i]->SetClippingPlanes(planes);
     683        }
     684    }
     685}
  • branches/blt4/packages/vizservers/vtkvis/RpCutplane.h

    r2550 r2681  
    1414#include <vtkActor.h>
    1515#include <vtkPlaneCollection.h>
    16 #include <vtkGaussianSplatter.h>
    17 #include <vtkExtractVOI.h>
     16#include <vtkCutter.h>
    1817#include <vtkPlane.h>
    1918
    2019#include "ColorMap.h"
     20#include "RpTypes.h"
    2121#include "RpVtkGraphicsObject.h"
    2222
     
    3131class Cutplane : public VtkGraphicsObject {
    3232public:
    33     enum Axis {
    34         X_AXIS,
    35         Y_AXIS,
    36         Z_AXIS
    37     };
    3833    enum ColorMode {
    3934        COLOR_BY_SCALAR,
     
    5348
    5449    virtual void setDataSet(DataSet *dataSet,
    55                             bool useCumulative,
    56                             double scalarRange[2],
    57                             double vectorMagnitudeRange[2],
    58                             double vectorComponentRange[3][2]);
     50                            Renderer *renderer);
    5951
    6052    virtual void setClippingPlanes(vtkPlaneCollection *planes);
    6153
    6254    void selectVolumeSlice(Axis axis, double ratio);
     55
     56    void setSliceVisibility(Axis axis, bool state);
     57
     58    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     59                      const char *name, double range[2] = NULL);
     60
     61    void setColorMode(ColorMode mode,
     62                      const char *name, double range[2] = NULL);
    6363
    6464    void setColorMode(ColorMode mode);
     
    7676    void updateColorMap();
    7777
    78     virtual void updateRanges(bool useCumulative,
    79                               double scalarRange[2],
    80                               double vectorMagnitudeRange[2],
    81                               double vectorComponentRange[3][2]);
     78    virtual void updateRanges(Renderer *renderer);
    8279
    8380private:
     81    virtual void initProp();
    8482    virtual void update();
    8583
     84    ColorMap *_colorMap;
    8685    ColorMode _colorMode;
    87     ColorMap *_colorMap;
    88     Axis _sliceAxis;
     86    std::string _colorFieldName;
     87    DataSet::DataAttributeType _colorFieldType;
     88    double _colorFieldRange[2];
    8989    double _vectorMagnitudeRange[2];
    9090    double _vectorComponentRange[3][2];
     91    Renderer *_renderer;
    9192
    9293    vtkSmartPointer<vtkLookupTable> _lut;
    93     vtkSmartPointer<vtkDataSetMapper> _mapper;
    94     vtkSmartPointer<vtkGaussianSplatter> _pointSplatter;
    95     vtkSmartPointer<vtkExtractVOI> _volumeSlicer;
    96     vtkSmartPointer<vtkPlane> _cutPlane;
     94    vtkSmartPointer<vtkActor> _actor[3];
     95    vtkSmartPointer<vtkDataSetMapper> _mapper[3];
     96    vtkSmartPointer<vtkCutter> _cutter[3];
     97    vtkSmartPointer<vtkPlane> _cutPlane[3];
    9798};
    9899
  • branches/blt4/packages/vizservers/vtkvis/RpGlyphs.cpp

    r2542 r2681  
    55 * Author: Leif Delgass <ldelgass@purdue.edu>
    66 */
     7
     8#include <cstring>
     9#include <cfloat>
    710
    811#include <vtkDataSet.h>
     
    2528
    2629#include "RpGlyphs.h"
     30#include "RpVtkRenderer.h"
    2731#include "Trace.h"
    2832
     
    3640    _scaleFactor(1.0),
    3741    _normalizeScale(true),
    38     _colorMode(COLOR_BY_SCALAR),
    39     _colorMap(NULL)
     42    _colorMap(NULL),
     43    _colorMode(COLOR_BY_SCALAR)
    4044{
    4145    _faceCulling = true;
     46    _scalingFieldRange[0] = DBL_MAX;
     47    _scalingFieldRange[1] = -DBL_MAX;
     48    _colorFieldRange[0] = DBL_MAX;
     49    _colorFieldRange[1] = -DBL_MAX;
    4250}
    4351
    4452Glyphs::~Glyphs()
    4553{
     54#ifdef WANT_TRACE
     55    if (_dataSet != NULL)
     56        TRACE("Deleting Glyphs for %s", _dataSet->getName().c_str());
     57    else
     58        TRACE("Deleting Glyphs with NULL DataSet");
     59#endif
    4660}
    4761
    4862void Glyphs::setDataSet(DataSet *dataSet,
    49                         bool useCumulative,
    50                         double scalarRange[2],
    51                         double vectorMagnitudeRange[2],
    52                         double vectorComponentRange[3][2])
     63                        Renderer *renderer)
    5364{
    5465    if (_dataSet != dataSet) {
    5566        _dataSet = dataSet;
    5667
    57         if (useCumulative) {
    58             _dataRange[0] = scalarRange[0];
    59             _dataRange[1] = scalarRange[1];
    60             _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    61             _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     68        _renderer = renderer;
     69
     70        if (renderer->getUseCumulativeRange()) {
     71            renderer->getCumulativeDataRange(_dataRange,
     72                                             _dataSet->getActiveScalarsName(),
     73                                             1);
     74            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     75                                             _dataSet->getActiveVectorsName(),
     76                                             3);
    6277            for (int i = 0; i < 3; i++) {
    63                 _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    64                 _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     78                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     79                                                 _dataSet->getActiveVectorsName(),
     80                                                 3, i);
    6581            }
    6682        } else {
     
    240256#endif
    241257
     258    if (_lut == NULL) {
     259        setColorMap(ColorMap::getDefault());
     260    }
     261
    242262    if (ds->GetPointData()->GetScalars() == NULL) {
    243263        TRACE("Setting color mode to vector magnitude");
     
    248268    }
    249269
    250     if (_lut == NULL) {
    251         setColorMap(ColorMap::getDefault());
    252     }
    253 
    254270#ifdef HAVE_GLYPH3D_MAPPER
    255271    getActor()->SetMapper(_glyphMapper);
     
    281297}
    282298
     299#ifdef HAVE_GLYPH3D_MAPPER
    283300/**
    284301 * \brief Control how glyphs are scaled
    285302 */
    286 void Glyphs::setScalingMode(ScalingMode mode)
     303void Glyphs::setScalingMode(ScalingMode mode, const char *name, double range[2])
    287304{
    288305    _scalingMode = mode;
    289 #ifdef HAVE_GLYPH3D_MAPPER
    290     if (_glyphMapper != NULL) {
    291 #else
    292     if (_glyphGenerator != NULL) {
    293 #endif
     306
     307    if (_dataSet == NULL || _glyphMapper == NULL)
     308        return;
     309
     310    if (name != NULL && strlen(name) > 0) {
     311        if (!_dataSet->hasField(name, DataSet::POINT_DATA)) {
     312            ERROR("Field not found: %s", name);
     313            return;
     314        }
     315        _scalingFieldName = name;
     316    } else
     317        _scalingFieldName.clear();
     318    if (range == NULL) {
     319        _scalingFieldRange[0] = DBL_MAX;
     320        _scalingFieldRange[1] = -DBL_MAX;
     321    } else {
     322        memcpy(_scalingFieldRange, range, sizeof(double)*2);
     323    }
     324
     325    if (name != NULL && strlen(name) > 0) {
     326        _glyphMapper->SetScaleArray(name);
     327    } else {
     328        if (mode == SCALE_BY_SCALAR) {
     329            _glyphMapper->SetScaleArray(vtkDataSetAttributes::SCALARS);
     330        } else {
     331            _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
     332        }
     333    }
     334
     335    if (range != NULL) {
     336        TRACE("Setting size range to: %g,%g", range[0], range[1]);
     337        _glyphMapper->SetRange(range);
     338    } else if (name != NULL && strlen(name) > 0) {
     339        double r[2];
     340        DataSet::DataAttributeType type = DataSet::POINT_DATA;
     341        int comp = -1;
     342
     343        if (_renderer->getUseCumulativeRange()) {
     344            int numComponents;
     345            if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     346                ERROR("Field not found: %s, type: %d", name, type);
     347                return;
     348            } else if (mode == SCALE_BY_VECTOR_COMPONENTS && numComponents < 3) {
     349                ERROR("Field %s needs 3 components but has only %d components",
     350                      name, numComponents);
     351                return;
     352            }
     353            if (mode == SCALE_BY_VECTOR_COMPONENTS) {
     354                double tmpR[2];
     355                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 0);
     356                r[0] = tmpR[0];
     357                r[1] = tmpR[1];
     358                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 1);
     359                r[0] = min2(r[0], tmpR[0]);
     360                r[1] = max2(r[1], tmpR[1]);
     361                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 2);
     362                r[0] = min2(r[0], tmpR[0]);
     363                r[1] = max2(r[1], tmpR[1]);
     364            } else {
     365                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     366            }
     367        } else {
     368            if (mode == SCALE_BY_VECTOR_COMPONENTS) {
     369                double tmpR[2];
     370                _dataSet->getDataRange(tmpR, name, type, 0);
     371                r[0] = tmpR[0];
     372                r[1] = tmpR[1];
     373                _dataSet->getDataRange(tmpR, name, type, 1);
     374                r[0] = min2(r[0], tmpR[0]);
     375                r[1] = max2(r[1], tmpR[1]);
     376                _dataSet->getDataRange(tmpR, name, type, 2);
     377                r[0] = min2(r[0], tmpR[0]);
     378                r[1] = max2(r[1], tmpR[1]);
     379            } else {
     380                _dataSet->getDataRange(r, name, type, comp);
     381            }
     382        }
     383        TRACE("Setting size range to: %g,%g", r[0], r[1]);
     384        _glyphMapper->SetRange(r);
     385    } else {
    294386        switch (mode) {
    295         case SCALE_BY_SCALAR: {
    296 #ifdef HAVE_GLYPH3D_MAPPER
     387        case SCALE_BY_SCALAR:
     388            TRACE("Setting size range to: %g,%g", _dataRange[0], _dataRange[1]);
    297389            _glyphMapper->SetRange(_dataRange);
    298             _glyphMapper->SetScaleModeToScaleByMagnitude();
    299             _glyphMapper->SetScaleArray(vtkDataSetAttributes::SCALARS);
    300 #else
    301             _glyphGenerator->SetRange(_dataRange);
    302             _glyphGenerator->SetScaleModeToScaleByScalar();
    303 #endif
    304         }
    305             break;
    306         case SCALE_BY_VECTOR_MAGNITUDE: {
    307 #ifdef HAVE_GLYPH3D_MAPPER
    308             _glyphMapper->SetRange(_dataRange);
    309             _glyphMapper->SetScaleModeToScaleByMagnitude();
    310             _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
    311 #else
    312             _glyphGenerator->SetRange(_vectorMagnitudeRange);
    313             _glyphGenerator->SetScaleModeToScaleByVector();
    314 #endif
    315         }
     390            break;
     391        case SCALE_BY_VECTOR_MAGNITUDE:
     392            TRACE("Setting size range to: %g,%g", _vectorMagnitudeRange[0], _vectorMagnitudeRange[1]);
     393            _glyphMapper->SetRange(_vectorMagnitudeRange);
    316394            break;
    317395        case SCALE_BY_VECTOR_COMPONENTS: {
     
    323401            sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[2][0]);
    324402            sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[2][1]);
    325 #ifdef HAVE_GLYPH3D_MAPPER
     403            TRACE("Setting size range to: %g,%g", sizeRange[0], sizeRange[1]);
    326404            _glyphMapper->SetRange(sizeRange);
    327             _glyphMapper->SetScaleModeToScaleByVectorComponents();
    328             _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
    329 #else
     405        }
     406            break;
     407        case SCALING_OFF:
     408        default:
     409            ;
     410        }
     411    }
     412
     413    switch (mode) {
     414    case SCALE_BY_SCALAR:
     415    case SCALE_BY_VECTOR_MAGNITUDE:
     416        _glyphMapper->SetScaleModeToScaleByMagnitude();
     417        break;
     418    case SCALE_BY_VECTOR_COMPONENTS:
     419        _glyphMapper->SetScaleModeToScaleByVectorComponents();
     420        break;
     421    case SCALING_OFF:
     422    default:
     423        _glyphMapper->SetScaleModeToNoDataScaling();
     424    }
     425}
     426
     427void Glyphs::setScalingMode(ScalingMode mode)
     428{
     429    setScalingMode(mode, NULL, NULL);
     430}
     431
     432void Glyphs::setColorMode(ColorMode mode,
     433                          const char *name, double range[2])
     434{
     435    _colorMode = mode;
     436    if (name == NULL)
     437        _colorFieldName.clear();
     438    else
     439        _colorFieldName = name;
     440    if (range == NULL) {
     441        _colorFieldRange[0] = DBL_MAX;
     442        _colorFieldRange[1] = -DBL_MAX;
     443    } else {
     444        memcpy(_colorFieldRange, range, sizeof(double)*2);
     445    }
     446
     447    if (_dataSet == NULL || _glyphMapper == NULL)
     448        return;
     449
     450    if (name != NULL && strlen(name) > 0) {
     451        _glyphMapper->SetScalarModeToUsePointFieldData();
     452        _glyphMapper->SelectColorArray(name);
     453    } else {
     454        _glyphMapper->SetScalarModeToDefault();
     455    }
     456
     457    if (_lut != NULL) {
     458        if (range != NULL) {
     459            _lut->SetRange(range);
     460        } else if (name != NULL && strlen(name) > 0) {
     461            double r[2];
     462            int comp = -1;
     463            if (mode == COLOR_BY_VECTOR_X)
     464                comp = 0;
     465            else if (mode == COLOR_BY_VECTOR_Y)
     466                comp = 1;
     467            else if (mode == COLOR_BY_VECTOR_Z)
     468                comp = 2;
     469
     470            DataSet::DataAttributeType type = DataSet::POINT_DATA;
     471
     472            if (_renderer->getUseCumulativeRange()) {
     473                int numComponents;
     474                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     475                    ERROR("Field not found: %s, type: %d", name, type);
     476                    return;
     477                } else if (numComponents < comp+1) {
     478                    ERROR("Request for component %d in field with %d components",
     479                          comp, numComponents);
     480                    return;
     481                }
     482                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     483            } else {
     484                _dataSet->getDataRange(r, name, type, comp);
     485            }
     486            TRACE("Setting lut range to: %g,%g", r[0], r[1]);
     487            _lut->SetRange(r);
     488        }
     489    }
     490
     491    switch (mode) {
     492    case COLOR_BY_SCALAR:
     493        _glyphMapper->ScalarVisibilityOn();
     494        break;
     495    case COLOR_BY_VECTOR_MAGNITUDE:
     496        _glyphMapper->ScalarVisibilityOn();
     497        if (_lut != NULL) {
     498            _lut->SetVectorModeToMagnitude();
     499        }
     500        break;
     501    case COLOR_BY_VECTOR_X:
     502        _glyphMapper->ScalarVisibilityOn();
     503        if (_lut != NULL) {
     504            _lut->SetVectorModeToComponent();
     505            _lut->SetVectorComponent(0);
     506        }
     507        break;
     508    case COLOR_BY_VECTOR_Y:
     509        _glyphMapper->ScalarVisibilityOn();
     510        if (_lut != NULL) {
     511            _lut->SetVectorModeToComponent();
     512            _lut->SetVectorComponent(1);
     513        }
     514        break;
     515    case COLOR_BY_VECTOR_Z:
     516        _glyphMapper->ScalarVisibilityOn();
     517        if (_lut != NULL) {
     518            _lut->SetVectorModeToComponent();
     519            _lut->SetVectorComponent(2);
     520        }
     521        break;
     522    case COLOR_CONSTANT:
     523    default:
     524        _glyphMapper->ScalarVisibilityOff();
     525        break;
     526    }
     527}
     528
     529void Glyphs::setColorMode(ColorMode mode)
     530{
     531    _colorMode = mode;
     532    if (_dataSet == NULL)
     533        return;
     534
     535    switch (mode) {
     536    case COLOR_BY_SCALAR:
     537        setColorMode(mode,
     538                     _dataSet->getActiveScalarsName(),
     539                     _dataRange);
     540        break;
     541    case COLOR_BY_VECTOR_MAGNITUDE:
     542        setColorMode(mode,
     543                     _dataSet->getActiveVectorsName(),
     544                     _vectorMagnitudeRange);
     545        break;
     546    case COLOR_BY_VECTOR_X:
     547        setColorMode(mode,
     548                     _dataSet->getActiveVectorsName(),
     549                     _vectorComponentRange[0]);
     550        break;
     551    case COLOR_BY_VECTOR_Y:
     552        setColorMode(mode,
     553                     _dataSet->getActiveVectorsName(),
     554                     _vectorComponentRange[1]);
     555        break;
     556    case COLOR_BY_VECTOR_Z:
     557        setColorMode(mode,
     558                     _dataSet->getActiveVectorsName(),
     559                     _vectorComponentRange[2]);
     560        break;
     561    case COLOR_CONSTANT:
     562    default:
     563        setColorMode(mode, NULL, NULL);
     564        break;
     565    }
     566}
     567
     568#else
     569
     570/**
     571 * \brief Control how glyphs are scaled
     572 */
     573void Glyphs::setScalingMode(ScalingMode mode)
     574{
     575    _scalingMode = mode;
     576    if (_glyphGenerator != NULL) {
     577        switch (mode) {
     578        case SCALE_BY_SCALAR:
     579            _glyphGenerator->SetRange(_dataRange);
     580            _glyphGenerator->SetScaleModeToScaleByScalar();
     581            break;
     582        case SCALE_BY_VECTOR_MAGNITUDE:
     583            _glyphGenerator->SetRange(_vectorMagnitudeRange);
     584            _glyphGenerator->SetScaleModeToScaleByVector();
     585            break;
     586        case SCALE_BY_VECTOR_COMPONENTS: {
     587            double sizeRange[2];
     588            sizeRange[0] = _vectorComponentRange[0][0];
     589            sizeRange[1] = _vectorComponentRange[0][1];
     590            sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[1][0]);
     591            sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[1][1]);
     592            sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[2][0]);
     593            sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[2][1]);
    330594            _glyphGenerator->SetRange(sizeRange);
    331595            _glyphGenerator->SetScaleModeToScaleByVectorComponents();
    332 #endif
    333596        }
    334597            break;
    335598        case SCALING_OFF:
    336599        default:
    337 #ifdef HAVE_GLYPH3D_MAPPER
    338             _glyphMapper->SetScaleModeToNoDataScaling();
    339 #else
    340600            _glyphGenerator->SetScaleModeToDataScalingOff();
    341 #endif
    342601        }
    343602    }
     
    350609{
    351610    _colorMode = mode;
    352 #ifdef HAVE_GLYPH3D_MAPPER
    353     if (_glyphMapper != NULL) {
    354 #else
    355611    if (_glyphGenerator != NULL) {
    356 #endif
    357612        switch (mode) {
    358         case COLOR_BY_VECTOR_MAGNITUDE: {
    359 #ifdef HAVE_GLYPH3D_MAPPER
    360             _glyphMapper->ScalarVisibilityOn();
    361             _glyphMapper->SetScalarModeToUsePointFieldData();
    362             vtkDataSet *ds = _dataSet->getVtkDataSet();
    363             if (ds->GetPointData() != NULL &&
    364                 ds->GetPointData()->GetVectors() != NULL) {
    365                 _glyphMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    366             }
    367 #else
     613        case COLOR_BY_VECTOR_MAGNITUDE:
    368614            _glyphGenerator->SetColorModeToColorByVector();
    369615            _pdMapper->ScalarVisibilityOn();
    370 #endif
    371616            if (_lut != NULL) {
    372617                _lut->SetVectorModeToMagnitude();
    373618                _lut->SetRange(_vectorMagnitudeRange);
    374619            }
    375         }
    376             break;
    377         case COLOR_BY_SCALAR: {
    378 #ifdef HAVE_GLYPH3D_MAPPER
    379             _glyphMapper->ScalarVisibilityOn();
    380             _glyphMapper->SetScalarModeToDefault();
    381 #else
     620            break;
     621        case COLOR_BY_SCALAR:
    382622            _glyphGenerator->SetColorModeToColorByScalar();
    383623            _pdMapper->ScalarVisibilityOn();
    384 #endif
    385624            if (_lut != NULL) {
    386625                _lut->SetRange(_dataRange);
    387626            }
    388         }
    389627            break;
    390628        case COLOR_CONSTANT:
     629            _pdMapper->ScalarVisibilityOff();
     630            break;
    391631        default:
    392 #ifdef HAVE_GLYPH3D_MAPPER
    393             _glyphMapper->ScalarVisibilityOff();
    394 #else
    395             _pdMapper->ScalarVisibilityOff();
    396 #endif
    397         }
    398      }
    399 }
     632            ERROR("Unsupported ColorMode: %d", mode);
     633        }
     634    }
     635}
     636
     637#endif
    400638
    401639/**
     
    416654}
    417655
    418 void Glyphs::updateRanges(bool useCumulative,
    419                           double scalarRange[2],
    420                           double vectorMagnitudeRange[2],
    421                           double vectorComponentRange[3][2])
    422 {
    423     if (useCumulative) {
    424         _dataRange[0] = scalarRange[0];
    425         _dataRange[1] = scalarRange[1];
    426         _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    427         _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     656void Glyphs::updateRanges(Renderer *renderer)
     657{
     658    if (_dataSet == NULL) {
     659        ERROR("called before setDataSet");
     660        return;
     661    }
     662
     663    if (renderer->getUseCumulativeRange()) {
     664        renderer->getCumulativeDataRange(_dataRange,
     665                                         _dataSet->getActiveScalarsName(),
     666                                         1);
     667        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     668                                         _dataSet->getActiveVectorsName(),
     669                                         3);
    428670        for (int i = 0; i < 3; i++) {
    429             _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    430             _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     671            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     672                                             _dataSet->getActiveVectorsName(),
     673                                             3, i);
    431674        }
    432675    } else {
     
    439682
    440683    // Need to update color map ranges and/or active vector field
     684#ifdef HAVE_GLYPH3D_MAPPER
     685    double *rangePtr = _colorFieldRange;
     686    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     687        rangePtr = NULL;
     688    }
     689    setColorMode(_colorMode, _colorFieldName.c_str(), rangePtr);
     690
     691    rangePtr = _scalingFieldRange;
     692    if (_scalingFieldRange[0] > _scalingFieldRange[1]) {
     693        rangePtr = NULL;
     694    }
     695    setScalingMode(_scalingMode, _scalingFieldName.c_str(), rangePtr);
     696#else
    441697    setColorMode(_colorMode);
    442698    setScalingMode(_scalingMode);
     699#endif
    443700}
    444701
     
    474731        }
    475732#endif
    476     }
    477 
    478     _lut->DeepCopy(cmap->getLookupTable());
     733        _lut->DeepCopy(cmap->getLookupTable());
     734        switch (_colorMode) {
     735        case COLOR_CONSTANT:
     736        case COLOR_BY_SCALAR:
     737            _lut->SetRange(_dataRange);
     738            break;
     739        case COLOR_BY_VECTOR_MAGNITUDE:
     740            _lut->SetRange(_vectorMagnitudeRange);
     741            break;
     742        case COLOR_BY_VECTOR_X:
     743            _lut->SetRange(_vectorComponentRange[0]);
     744            break;
     745        case COLOR_BY_VECTOR_Y:
     746            _lut->SetRange(_vectorComponentRange[1]);
     747            break;
     748        case COLOR_BY_VECTOR_Z:
     749            _lut->SetRange(_vectorComponentRange[2]);
     750            break;
     751        default:
     752            break;
     753        }
     754    } else {
     755        double range[2];
     756        _lut->GetTableRange(range);
     757        _lut->DeepCopy(cmap->getLookupTable());
     758        _lut->SetRange(range);
     759    }
    479760
    480761    switch (_colorMode) {
    481762    case COLOR_BY_VECTOR_MAGNITUDE:
    482         _lut->SetRange(_vectorMagnitudeRange);
    483763        _lut->SetVectorModeToMagnitude();
    484764        break;
    485     case COLOR_BY_SCALAR:
     765    case COLOR_BY_VECTOR_X:
     766        _lut->SetVectorModeToComponent();
     767        _lut->SetVectorComponent(0);
     768        break;
     769    case COLOR_BY_VECTOR_Y:
     770        _lut->SetVectorModeToComponent();
     771        _lut->SetVectorComponent(1);
     772        break;
     773    case COLOR_BY_VECTOR_Z:
     774        _lut->SetVectorModeToComponent();
     775        _lut->SetVectorComponent(2);
     776        break;
    486777    default:
    487         _lut->SetRange(_dataRange);
    488778        break;
    489779    }
  • branches/blt4/packages/vizservers/vtkvis/RpGlyphs.h

    r2550 r2681  
    5858        COLOR_BY_SCALAR,
    5959        COLOR_BY_VECTOR_MAGNITUDE,
     60        COLOR_BY_VECTOR_X,
     61        COLOR_BY_VECTOR_Y,
     62        COLOR_BY_VECTOR_Z,
    6063        COLOR_CONSTANT
    6164    };
     
    7073
    7174    virtual void setDataSet(DataSet *dataSet,
    72                             bool useCumulative,
    73                             double scalarRange[2],
    74                             double vectorMagnitudeRange[2],
    75                             double vectorComponentRange[3][2]);
     75                            Renderer *renderer);
    7676
    7777    virtual void setClippingPlanes(vtkPlaneCollection *planes);
     78
     79#ifdef HAVE_GLYPH3D_MAPPER
     80    void setScalingMode(ScalingMode mode, const char *name, double range[2]);
     81
     82    void setColorMode(ColorMode mode, const char *name, double range[2]);
     83#endif
    7884
    7985    void setScalingMode(ScalingMode mode);
     
    99105    void updateColorMap();
    100106
    101     virtual void updateRanges(bool useCumulative,
    102                               double scalarRange[2],
    103                               double vectorMagnitudeRange[2],
    104                               double vectorComponentRange[3][2]);
     107    virtual void updateRanges(Renderer *renderer);
    105108
    106109private:
     
    118121    GlyphShape _glyphShape;
    119122    ScalingMode _scalingMode;
     123    std::string _scalingFieldName;
     124    double _scalingFieldRange[2];
    120125    double _dataScale;
    121126    double _scaleFactor;
    122127    bool _normalizeScale;
     128    ColorMap *_colorMap;
    123129    ColorMode _colorMode;
    124     ColorMap *_colorMap;
     130    std::string _colorFieldName;
     131    double _colorFieldRange[2];
    125132    double _vectorMagnitudeRange[2];
    126133    double _vectorComponentRange[3][2];
     134    Renderer *_renderer;
    127135
    128136    vtkSmartPointer<vtkLookupTable> _lut;
  • branches/blt4/packages/vizservers/vtkvis/RpHeightMap.cpp

    r2550 r2681  
    3232
    3333#include "RpHeightMap.h"
     34#include "RpVtkRenderer.h"
    3435#include "Trace.h"
    3536
     
    7879
    7980void HeightMap::setDataSet(DataSet *dataSet,
    80                            bool useCumulative,
    81                            double scalarRange[2],
    82                            double vectorMagnitudeRange[2],
    83                            double vectorComponentRange[3][2])
     81                           Renderer *renderer)
    8482{
    8583    if (_dataSet != dataSet) {
     
    8785
    8886        if (_dataSet != NULL) {
    89             if (useCumulative) {
    90                 _dataRange[0] = scalarRange[0];
    91                 _dataRange[1] = scalarRange[1];
     87            if (renderer->getUseCumulativeRange()) {
     88                renderer->getCumulativeDataRange(_dataRange,
     89                                                 _dataSet->getActiveScalarsName(),
     90                                                 1);
    9291            } else {
    9392                _dataSet->getScalarRange(_dataRange);
     
    207206                pd->GetNumberOfStrips() == 0) {
    208207                // DataSet is a point cloud
    209                 DataSet::PrincipalPlane plane;
     208                PrincipalPlane plane;
    210209                double offset;
    211210                if (_dataSet->is2D(&plane, &offset)) {
     
    213212                    // Result of Delaunay2D is a PolyData
    214213                    vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    215                     if (plane == DataSet::PLANE_ZY) {
     214                    if (plane == PLANE_ZY) {
    216215                        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    217216                        trans->RotateWXYZ(90, 0, 1, 0);
     
    221220                        mesher->SetTransform(trans);
    222221                        _sliceAxis = X_AXIS;
    223                     } else if (plane == DataSet::PLANE_XZ) {
     222                    } else if (plane == PLANE_XZ) {
    224223                        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    225224                        trans->RotateWXYZ(-90, 1, 0, 0);
     
    248247                    _pointSplatter->GetSampleDimensions(dims);
    249248                    TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
    250                     if (plane == DataSet::PLANE_ZY) {
     249                    if (plane == PLANE_ZY) {
    251250                        dims[0] = 3;
    252251                        _volumeSlicer->SetVOI(1, 1, 0, dims[1]-1, 0, dims[1]-1);
    253252                        _sliceAxis = X_AXIS;
    254                     } else if (plane == DataSet::PLANE_XZ) {
     253                    } else if (plane == PLANE_XZ) {
    255254                        dims[1] = 3;
    256255                        _volumeSlicer->SetVOI(0, dims[0]-1, 1, 1, 0, dims[2]-1);
     
    660659}
    661660
    662 void HeightMap::updateRanges(bool useCumulative,
    663                              double scalarRange[2],
    664                              double vectorMagnitudeRange[2],
    665                              double vectorComponentRange[3][2])
    666 {
    667     if (useCumulative) {
    668         _dataRange[0] = scalarRange[0];
    669         _dataRange[1] = scalarRange[1];
    670     } else if (_dataSet != NULL) {
    671         _dataSet->getScalarRange(_dataRange);
    672     }
     661void HeightMap::updateRanges(Renderer *renderer)
     662{
     663    VtkGraphicsObject::updateRanges(renderer);
    673664
    674665    if (_lut != NULL) {
  • branches/blt4/packages/vizservers/vtkvis/RpHeightMap.h

    r2550 r2681  
    2626
    2727#include "ColorMap.h"
     28#include "RpTypes.h"
    2829#include "RpVtkGraphicsObject.h"
    2930
     
    3637class HeightMap : public VtkGraphicsObject {
    3738public:
    38     enum Axis {
    39         X_AXIS,
    40         Y_AXIS,
    41         Z_AXIS
    42     };
    43 
    4439    HeightMap(int numContours, double heightScale = 1.0);
    4540
     
    5348    }
    5449
    55     virtual void setDataSet(DataSet *dataset,
    56                             bool useCumulative,
    57                             double scalarRange[2],
    58                             double vectorMagnitudeRange[2],
    59                             double vectorComponentRange[3][2]);
     50    virtual void setDataSet(DataSet *dataSet,
     51                            Renderer *renderer);
    6052
    6153    virtual void setLighting(bool state);
     
    9890    void updateColorMap();
    9991
    100     virtual void updateRanges(bool useCumulative,
    101                               double scalarRange[2],
    102                               double vectorMagnitudeRange[2],
    103                               double vectorComponentRange[3][2]);
     92    virtual void updateRanges(Renderer *renderer);
    10493
    10594    void setContourLineVisibility(bool state);
  • branches/blt4/packages/vizservers/vtkvis/RpLIC.cpp

    r2550 r2681  
    3636LIC::~LIC()
    3737{
     38#ifdef WANT_TRACE
     39    if (_dataSet != NULL)
     40        TRACE("Deleting LIC for %s", _dataSet->getName().c_str());
     41    else
     42        TRACE("Deleting LIC with NULL DataSet");
     43#endif
    3844}
    3945
     
    395401}
    396402
    397 void LIC::updateRanges(bool useCumulative,
    398                        double scalarRange[2],
    399                        double vectorMagnitudeRange[2],
    400                        double vectorComponentRange[3][2])
    401 {
    402     if (useCumulative) {
    403         _dataRange[0] = scalarRange[0];
    404         _dataRange[1] = scalarRange[1];
    405     } else if (_dataSet != NULL) {
    406         _dataSet->getScalarRange(_dataRange);
    407     }
     403void LIC::updateRanges(Renderer *renderer)
     404{
     405    VtkGraphicsObject::updateRanges(renderer);
    408406
    409407    if (_lut != NULL) {
  • branches/blt4/packages/vizservers/vtkvis/RpLIC.h

    r2542 r2681  
    2121
    2222#include "ColorMap.h"
     23#include "RpTypes.h"
    2324#include "RpVtkGraphicsObject.h"
    2425
     
    3334class LIC : public VtkGraphicsObject {
    3435public:
    35     enum Axis {
    36         X_AXIS,
    37         Y_AXIS,
    38         Z_AXIS
    39     };
    40 
    4136    LIC();
    4237    virtual ~LIC();
     
    6358    void updateColorMap();
    6459
    65     virtual void updateRanges(bool useCumulative,
    66                               double scalarRange[2],
    67                               double vectorMagnitudeRange[2],
    68                               double vectorComponentRange[3][2]);
     60    virtual void updateRanges(Renderer *renderer);
    6961
    7062private:
  • branches/blt4/packages/vizservers/vtkvis/RpMolecule.cpp

    r2542 r2681  
    167167}
    168168
    169 void Molecule::updateRanges(bool useCumulative,
    170                             double scalarRange[2],
    171                             double vectorMagnitudeRange[2],
    172                             double vectorComponentRange[3][2])
    173 {
    174     if (useCumulative) {
    175         _dataRange[0] = scalarRange[0];
    176         _dataRange[1] = scalarRange[1];
    177     } else if (_dataSet != NULL) {
    178         _dataSet->getScalarRange(_dataRange);
    179     }
    180 
    181     if (_lut != NULL) {
     169void Molecule::updateRanges(Renderer *renderer)
     170{
     171    VtkGraphicsObject::updateRanges(renderer);
     172
     173    if (_lut != NULL && _dataSet != NULL) {
    182174        vtkDataSet *ds = _dataSet->getVtkDataSet();
    183175        if (ds == NULL)
  • branches/blt4/packages/vizservers/vtkvis/RpMolecule.h

    r2542 r2681  
    6464    void updateColorMap();
    6565
    66     virtual void updateRanges(bool useCumulative,
    67                               double scalarRange[2],
    68                               double vectorMagnitudeRange[2],
    69                               double vectorComponentRange[3][2]);
     66    virtual void updateRanges(Renderer *renderer);
    7067
    7168    void setAtomScaling(AtomScaling state);
  • branches/blt4/packages/vizservers/vtkvis/RpPolyData.cpp

    r2542 r2681  
    4848{
    4949    VtkGraphicsObject::initProp();
    50     getActor()->GetProperty()->EdgeVisibilityOn();
    5150}
    5251
     
    8079            pd->GetNumberOfStrips() == 0) {
    8180            // DataSet is a point cloud
    82             DataSet::PrincipalPlane plane;
     81            PrincipalPlane plane;
    8382            double offset;
    8483            if (_dataSet->numDimensions() < 2 || pd->GetNumberOfPoints() < 3) {
     
    8786            } else if (_dataSet->is2D(&plane, &offset)) {
    8887                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    89                 if (plane == DataSet::PLANE_ZY) {
     88                if (plane == PLANE_ZY) {
    9089                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    9190                    trans->RotateWXYZ(90, 0, 1, 0);
     
    9493                    }
    9594                    mesher->SetTransform(trans);
    96                 } else if (plane == DataSet::PLANE_XZ) {
     95                } else if (plane == PLANE_XZ) {
    9796                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    9897                    trans->RotateWXYZ(-90, 1, 0, 0);
     
    159158
    160159    initProp();
     160    setVisibility(_dataSet->getVisibility());
    161161    getActor()->SetMapper(_pdMapper);
    162162    _pdMapper->Update();
  • branches/blt4/packages/vizservers/vtkvis/RpPseudoColor.cpp

    r2550 r2681  
    77
    88#include <cassert>
     9#include <cfloat>
     10#include <cstring>
    911
    1012#include <vtkDataSet.h>
     
    2426
    2527#include "RpPseudoColor.h"
     28#include "RpVtkRenderer.h"
    2629#include "Trace.h"
    2730
     
    3235PseudoColor::PseudoColor() :
    3336    VtkGraphicsObject(),
     37    _colorMap(NULL),
    3438    _colorMode(COLOR_BY_SCALAR),
    35     _colorMap(NULL)
    36 {
     39    _colorFieldType(DataSet::POINT_DATA),
     40    _renderer(NULL)
     41{
     42    _colorFieldRange[0] = DBL_MAX;
     43    _colorFieldRange[1] = -DBL_MAX;
    3744}
    3845
     
    4855
    4956void PseudoColor::setDataSet(DataSet *dataSet,
    50                              bool useCumulative,
    51                              double scalarRange[2],
    52                              double vectorMagnitudeRange[2],
    53                              double vectorComponentRange[3][2])
     57                             Renderer *renderer)
    5458{
    5559    if (_dataSet != dataSet) {
    5660        _dataSet = dataSet;
    5761
    58         if (useCumulative) {
    59             _dataRange[0] = scalarRange[0];
    60             _dataRange[1] = scalarRange[1];
    61             _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    62             _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     62        _renderer = renderer;
     63
     64        if (renderer->getUseCumulativeRange()) {
     65            renderer->getCumulativeDataRange(_dataRange,
     66                                             _dataSet->getActiveScalarsName(),
     67                                             1);
     68            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     69                                             _dataSet->getActiveVectorsName(),
     70                                             3);
    6371            for (int i = 0; i < 3; i++) {
    64                 _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    65                 _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     72                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     73                                                 _dataSet->getActiveVectorsName(),
     74                                                 3, i);
    6675            }
    6776        } else {
     
    102111            pd->GetNumberOfStrips() == 0) {
    103112            // DataSet is a point cloud
    104             DataSet::PrincipalPlane plane;
     113            PrincipalPlane plane;
    105114            double offset;
    106115            if (_dataSet->is2D(&plane, &offset)) {
    107116#ifdef MESH_POINT_CLOUDS
    108117                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
    109                 if (plane == DataSet::PLANE_ZY) {
     118                if (plane == PLANE_ZY) {
    110119                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    111120                    trans->RotateWXYZ(90, 0, 1, 0);
     
    114123                    }
    115124                    mesher->SetTransform(trans);
    116                 } else if (plane == DataSet::PLANE_XZ) {
     125                } else if (plane == PLANE_XZ) {
    117126                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
    118127                    trans->RotateWXYZ(-90, 1, 0, 0);
     
    136145                splatter->GetSampleDimensions(dims);
    137146                TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
    138                 if (plane == DataSet::PLANE_ZY) {
     147                if (plane == PLANE_ZY) {
    139148                    dims[0] = 3;
    140149                    slicer->SetVOI(1, 1, 0, dims[1]-1, 0, dims[1]-1);
    141                 } else if (plane == DataSet::PLANE_XZ) {
     150                } else if (plane == PLANE_XZ) {
    142151                    dims[1] = 3;
    143152                    slicer->SetVOI(0, dims[0]-1, 1, 1, 0, dims[2]-1);
     
    191200}
    192201
    193 void PseudoColor::updateRanges(bool useCumulative,
    194                                double scalarRange[2],
    195                                double vectorMagnitudeRange[2],
    196                                double vectorComponentRange[3][2])
    197 {
    198     if (useCumulative) {
    199         _dataRange[0] = scalarRange[0];
    200         _dataRange[1] = scalarRange[1];
    201         _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    202         _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     202void PseudoColor::updateRanges(Renderer *renderer)
     203{
     204    if (_dataSet == NULL) {
     205        ERROR("called before setDataSet");
     206        return;
     207    }
     208
     209    if (renderer->getUseCumulativeRange()) {
     210        renderer->getCumulativeDataRange(_dataRange,
     211                                         _dataSet->getActiveScalarsName(),
     212                                         1);
     213        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     214                                         _dataSet->getActiveVectorsName(),
     215                                         3);
    203216        for (int i = 0; i < 3; i++) {
    204             _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    205             _vectorComponentRange[i][1] = vectorComponentRange[i][1];
    206         }
    207     } else if (_dataSet != NULL) {
     217            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     218                                             _dataSet->getActiveVectorsName(),
     219                                             3, i);
     220        }
     221    } else {
    208222        _dataSet->getScalarRange(_dataRange);
    209223        _dataSet->getVectorRange(_vectorMagnitudeRange);
     
    213227    }
    214228
    215     // Need to update color map ranges and/or active vector field
    216     setColorMode(_colorMode);
     229    // Need to update color map ranges
     230    double *rangePtr = _colorFieldRange;
     231    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     232        rangePtr = NULL;
     233    }
     234    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
    217235}
    218236
     
    220238{
    221239    _colorMode = mode;
     240    if (_dataSet == NULL)
     241        return;
     242
     243    switch (mode) {
     244    case COLOR_BY_SCALAR:
     245        setColorMode(mode,
     246                     _dataSet->getActiveScalarsType(),
     247                     _dataSet->getActiveScalarsName(),
     248                     _dataRange);
     249        break;
     250    case COLOR_BY_VECTOR_MAGNITUDE:
     251        setColorMode(mode,
     252                     _dataSet->getActiveVectorsType(),
     253                     _dataSet->getActiveVectorsName(),
     254                     _vectorMagnitudeRange);
     255        break;
     256    case COLOR_BY_VECTOR_X:
     257        setColorMode(mode,
     258                     _dataSet->getActiveVectorsType(),
     259                     _dataSet->getActiveVectorsName(),
     260                     _vectorComponentRange[0]);
     261        break;
     262    case COLOR_BY_VECTOR_Y:
     263        setColorMode(mode,
     264                     _dataSet->getActiveVectorsType(),
     265                     _dataSet->getActiveVectorsName(),
     266                     _vectorComponentRange[1]);
     267        break;
     268    case COLOR_BY_VECTOR_Z:
     269        setColorMode(mode,
     270                     _dataSet->getActiveVectorsType(),
     271                     _dataSet->getActiveVectorsName(),
     272                     _vectorComponentRange[2]);
     273        break;
     274    case COLOR_CONSTANT:
     275    default:
     276        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
     277        break;
     278    }
     279}
     280
     281void PseudoColor::setColorMode(ColorMode mode,
     282                               const char *name, double range[2])
     283{
     284    if (_dataSet == NULL)
     285        return;
     286    DataSet::DataAttributeType type = DataSet::POINT_DATA;
     287    int numComponents = 1;
     288    if (name != NULL && strlen(name) > 0 &&
     289        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
     290        ERROR("Field not found: %s", name);
     291        return;
     292    }
     293    setColorMode(mode, type, name, range);
     294}
     295
     296void PseudoColor::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     297                               const char *name, double range[2])
     298{
     299    _colorMode = mode;
     300    _colorFieldType = type;
     301    if (name == NULL)
     302        _colorFieldName.clear();
     303    else
     304        _colorFieldName = name;
     305    if (range == NULL) {
     306        _colorFieldRange[0] = DBL_MAX;
     307        _colorFieldRange[1] = -DBL_MAX;
     308    } else {
     309        memcpy(_colorFieldRange, range, sizeof(double)*2);
     310    }
     311
    222312    if (_dataSet == NULL || _dsMapper == NULL)
    223313        return;
    224314
    225     vtkDataSet *ds = _dataSet->getVtkDataSet();
     315    switch (type) {
     316    case DataSet::POINT_DATA:
     317        _dsMapper->SetScalarModeToUsePointFieldData();
     318        break;
     319    case DataSet::CELL_DATA:
     320        _dsMapper->SetScalarModeToUseCellFieldData();
     321        break;
     322    default:
     323        ERROR("Unsupported DataAttributeType: %d", type);
     324        return;
     325    }
     326
     327    if (name != NULL && strlen(name) > 0) {
     328        _dsMapper->SelectColorArray(name);
     329    } else {
     330        _dsMapper->SetScalarModeToDefault();
     331    }
     332
     333    if (_lut != NULL) {
     334        if (range != NULL) {
     335            _lut->SetRange(range);
     336        } else if (name != NULL && strlen(name) > 0) {
     337            double r[2];
     338            int comp = -1;
     339            if (mode == COLOR_BY_VECTOR_X)
     340                comp = 0;
     341            else if (mode == COLOR_BY_VECTOR_Y)
     342                comp = 1;
     343            else if (mode == COLOR_BY_VECTOR_Z)
     344                comp = 2;
     345
     346            if (_renderer->getUseCumulativeRange()) {
     347                int numComponents;
     348                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     349                    ERROR("Field not found: %s, type: %d", name, type);
     350                    return;
     351                } else if (numComponents < comp+1) {
     352                    ERROR("Request for component %d in field with %d components",
     353                          comp, numComponents);
     354                    return;
     355                }
     356                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     357            } else {
     358                _dataSet->getDataRange(r, name, type, comp);
     359            }
     360            _lut->SetRange(r);
     361        }
     362    }
    226363
    227364    switch (mode) {
    228     case COLOR_BY_SCALAR: {
     365    case COLOR_BY_SCALAR:
    229366        _dsMapper->ScalarVisibilityOn();
    230         _dsMapper->SetScalarModeToDefault();
     367        break;
     368    case COLOR_BY_VECTOR_MAGNITUDE:
     369        _dsMapper->ScalarVisibilityOn();
    231370        if (_lut != NULL) {
    232             _lut->SetRange(_dataRange);
    233         }
    234     }
    235         break;
    236     case COLOR_BY_VECTOR_MAGNITUDE: {
    237         _dsMapper->ScalarVisibilityOn();
    238         if (ds->GetPointData() != NULL &&
    239             ds->GetPointData()->GetVectors() != NULL) {
    240             _dsMapper->SetScalarModeToUsePointFieldData();
    241             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    242         } else if (ds->GetCellData() != NULL &&
    243                    ds->GetCellData()->GetVectors() != NULL) {
    244             _dsMapper->SetScalarModeToUseCellFieldData();
    245             _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
    246         }
    247         if (_lut != NULL) {
    248             _lut->SetRange(_vectorMagnitudeRange);
    249371            _lut->SetVectorModeToMagnitude();
    250372        }
    251     }
    252373        break;
    253374    case COLOR_BY_VECTOR_X:
    254375        _dsMapper->ScalarVisibilityOn();
    255         if (ds->GetPointData() != NULL &&
    256             ds->GetPointData()->GetVectors() != NULL) {
    257             _dsMapper->SetScalarModeToUsePointFieldData();
    258             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    259         } else if (ds->GetCellData() != NULL &&
    260                    ds->GetCellData()->GetVectors() != NULL) {
    261             _dsMapper->SetScalarModeToUseCellFieldData();
    262             _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
    263         }
    264376        if (_lut != NULL) {
    265             _lut->SetRange(_vectorComponentRange[0]);
    266377            _lut->SetVectorModeToComponent();
    267378            _lut->SetVectorComponent(0);
     
    270381    case COLOR_BY_VECTOR_Y:
    271382        _dsMapper->ScalarVisibilityOn();
    272         if (ds->GetPointData() != NULL &&
    273             ds->GetPointData()->GetVectors() != NULL) {
    274             _dsMapper->SetScalarModeToUsePointFieldData();
    275             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    276         } else if (ds->GetCellData() != NULL &&
    277                    ds->GetCellData()->GetVectors() != NULL) {
    278             _dsMapper->SetScalarModeToUseCellFieldData();
    279             _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
    280         }
    281383        if (_lut != NULL) {
    282             _lut->SetRange(_vectorComponentRange[1]);
    283384            _lut->SetVectorModeToComponent();
    284385            _lut->SetVectorComponent(1);
     
    287388    case COLOR_BY_VECTOR_Z:
    288389        _dsMapper->ScalarVisibilityOn();
    289         if (ds->GetPointData() != NULL &&
    290             ds->GetPointData()->GetVectors() != NULL) {
    291             _dsMapper->SetScalarModeToUsePointFieldData();
    292             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
    293         } else if (ds->GetCellData() != NULL &&
    294                    ds->GetCellData()->GetVectors() != NULL) {
    295             _dsMapper->SetScalarModeToUseCellFieldData();
    296             _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
    297         }
    298390        if (_lut != NULL) {
    299             _lut->SetRange(_vectorComponentRange[2]);
    300391            _lut->SetVectorModeToComponent();
    301392            _lut->SetVectorComponent(2);
     
    333424            _dsMapper->SetLookupTable(_lut);
    334425        }
    335     }
    336 
    337     _lut->DeepCopy(cmap->getLookupTable());
     426        _lut->DeepCopy(cmap->getLookupTable());
     427        switch (_colorMode) {
     428        case COLOR_CONSTANT:
     429        case COLOR_BY_SCALAR:
     430            _lut->SetRange(_dataRange);
     431            break;
     432        case COLOR_BY_VECTOR_MAGNITUDE:
     433            _lut->SetRange(_vectorMagnitudeRange);
     434            break;
     435        case COLOR_BY_VECTOR_X:
     436            _lut->SetRange(_vectorComponentRange[0]);
     437            break;
     438        case COLOR_BY_VECTOR_Y:
     439            _lut->SetRange(_vectorComponentRange[1]);
     440            break;
     441        case COLOR_BY_VECTOR_Z:
     442            _lut->SetRange(_vectorComponentRange[2]);
     443            break;
     444        default:
     445            break;
     446        }
     447    } else {
     448        double range[2];
     449        _lut->GetTableRange(range);
     450        _lut->DeepCopy(cmap->getLookupTable());
     451        _lut->SetRange(range);
     452    }
    338453
    339454    switch (_colorMode) {
    340     case COLOR_CONSTANT:
    341     case COLOR_BY_SCALAR:
    342         _lut->SetRange(_dataRange);
    343         break;
    344455    case COLOR_BY_VECTOR_MAGNITUDE:
    345456        _lut->SetVectorModeToMagnitude();
    346         _lut->SetRange(_vectorMagnitudeRange);
    347457        break;
    348458    case COLOR_BY_VECTOR_X:
    349459        _lut->SetVectorModeToComponent();
    350460        _lut->SetVectorComponent(0);
    351         _lut->SetRange(_vectorComponentRange[0]);
    352461        break;
    353462    case COLOR_BY_VECTOR_Y:
    354463        _lut->SetVectorModeToComponent();
    355464        _lut->SetVectorComponent(1);
    356         _lut->SetRange(_vectorComponentRange[1]);
    357465        break;
    358466    case COLOR_BY_VECTOR_Z:
    359467        _lut->SetVectorModeToComponent();
    360468        _lut->SetVectorComponent(2);
    361         _lut->SetRange(_vectorComponentRange[2]);
    362469        break;
    363470    default:
  • branches/blt4/packages/vizservers/vtkvis/RpPseudoColor.h

    r2542 r2681  
    4444
    4545    virtual void setDataSet(DataSet *dataSet,
    46                             bool useCumulative,
    47                             double scalarRange[2],
    48                             double vectorMagnitudeRange[2],
    49                             double vectorComponentRange[3][2]);
     46                            Renderer *renderer);
    5047
    5148    virtual void setClippingPlanes(vtkPlaneCollection *planes);
     49
     50    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     51                      const char *name, double range[2] = NULL);
     52
     53    void setColorMode(ColorMode mode,
     54                      const char *name, double range[2] = NULL);
    5255
    5356    void setColorMode(ColorMode mode);
     
    6568    void updateColorMap();
    6669
    67     virtual void updateRanges(bool useCumulative,
    68                               double scalarRange[2],
    69                               double vectorMagnitudeRange[2],
    70                               double vectorComponentRange[3][2]);
     70    virtual void updateRanges(Renderer *renderer);
    7171
    7272private:
    7373    virtual void update();
    7474
     75    ColorMap *_colorMap;
    7576    ColorMode _colorMode;
    76     ColorMap *_colorMap;
     77    std::string _colorFieldName;
     78    DataSet::DataAttributeType _colorFieldType;
     79    double _colorFieldRange[2];
    7780    double _vectorMagnitudeRange[2];
    7881    double _vectorComponentRange[3][2];
     82    Renderer *_renderer;
    7983
    8084    vtkSmartPointer<vtkLookupTable> _lut;
  • branches/blt4/packages/vizservers/vtkvis/RpStreamlines.cpp

    r2550 r2681  
    1010#include <cfloat>
    1111#include <cmath>
     12#include <cstring>
    1213
    1314#include <vtkMath.h>
     
    3031
    3132#include "RpStreamlines.h"
     33#include "RpVtkRenderer.h"
    3234#include "Trace.h"
    3335
     
    3739    VtkGraphicsObject(),
    3840    _lineType(LINES),
     41    _colorMap(NULL),
    3942    _colorMode(COLOR_BY_VECTOR_MAGNITUDE),
    40     _colorMap(NULL),
     43    _colorFieldType(DataSet::POINT_DATA),
    4144    _seedVisible(true),
     45    _renderer(NULL),
    4246    _dataScale(1)
    4347{
     
    4953    _seedColor[1] = 1.0f;
    5054    _seedColor[2] = 1.0f;
     55    _colorFieldRange[0] = DBL_MAX;
     56    _colorFieldRange[1] = -DBL_MAX;
    5157    vtkMath::RandomSeed((int)time(NULL));
    5258    srand((unsigned int)time(NULL));
     
    5561Streamlines::~Streamlines()
    5662{
     63#ifdef WANT_TRACE
     64    if (_dataSet != NULL)
     65        TRACE("Deleting Streamlines for %s", _dataSet->getName().c_str());
     66    else
     67        TRACE("Deleting Streamlines with NULL DataSet");
     68#endif
    5769}
    5870
    5971void Streamlines::setDataSet(DataSet *dataSet,
    60                              bool useCumulative,
    61                              double scalarRange[2],
    62                              double vectorMagnitudeRange[2],
    63                              double vectorComponentRange[3][2])
     72                             Renderer *renderer)
    6473{
    6574    if (_dataSet != dataSet) {
    6675        _dataSet = dataSet;
    6776
    68         if (useCumulative) {
    69             _dataRange[0] = scalarRange[0];
    70             _dataRange[1] = scalarRange[1];
    71             _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    72             _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     77        _renderer = renderer;
     78
     79        if (renderer->getUseCumulativeRange()) {
     80            renderer->getCumulativeDataRange(_dataRange,
     81                                             _dataSet->getActiveScalarsName(),
     82                                             1);
     83            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     84                                             _dataSet->getActiveVectorsName(),
     85                                             3);
    7386            for (int i = 0; i < 3; i++) {
    74                 _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    75                 _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     87                renderer->getCumulativeDataRange(_vectorComponentRange[i],
     88                                                 _dataSet->getActiveVectorsName(),
     89                                                 3, i);
    7690            }
    7791        } else {
     
    189203    bary[2] = 1.0 - bary[0] - bary[1];
    190204
    191     TRACE("bary %g %g %g", bary[0], bary[1], bary[2]);
     205    //TRACE("bary %g %g %g", bary[0], bary[1], bary[2]);
    192206    // Convert to cartesian coords
    193207    for (int i = 0; i < 3; i++) {
     
    221235    }
    222236    bary[3] = 1.0 - bary[0] - bary[1] - bary[2];
    223     TRACE("bary %g %g %g %g", bary[0], bary[1], bary[2], bary[3]);
     237    //TRACE("bary %g %g %g %g", bary[0], bary[1], bary[2], bary[3]);
    224238    // Convert to cartesian coords
    225239    for (int i = 0; i < 3; i++) {
     
    553567}
    554568
     569void Streamlines::setNumberOfSeedPoints(int numPoints)
     570{
     571    switch(_seedType) {
     572    case DATASET_FILLED_MESH:
     573        setSeedToFilledMesh(numPoints);
     574        break;
     575    case FILLED_MESH:
     576        if (_seedMesh != NULL) {
     577            setSeedToFilledMesh(_seedMesh, numPoints);
     578        } else {
     579            ERROR("NULL _seedMesh");
     580        }
     581        break;
     582    default:
     583        ERROR("Can't set number of points for seed type %d", _seedType);
     584        break;
     585    }
     586}
     587
    555588/**
    556589 * \brief Use points of the DataSet associated with this
     
    559592void Streamlines::setSeedToMeshPoints()
    560593{
     594    _seedType = DATASET_MESH_POINTS;
    561595    setSeedToMeshPoints(_dataSet->getVtkDataSet());
    562596}
     
    574608void Streamlines::setSeedToFilledMesh(int numPoints)
    575609{
     610    _seedType = DATASET_FILLED_MESH;
    576611    setSeedToFilledMesh(_dataSet->getVtkDataSet(), numPoints);
    577612}
     
    584619void Streamlines::setSeedToMeshPoints(vtkDataSet *seed)
    585620{
     621    if (seed != _dataSet->getVtkDataSet()) {
     622        _seedType = MESH_POINTS;
     623    }
     624    _seedMesh = NULL;
    586625    if (_streamTracer != NULL) {
    587626        TRACE("Seed points: %d", seed->GetNumberOfPoints());
     
    619658void Streamlines::setSeedToFilledMesh(vtkDataSet *ds, int numPoints)
    620659{
     660    if (ds != _dataSet->getVtkDataSet()) {
     661        _seedMesh = ds;
     662        _seedType = FILLED_MESH;
     663    } else {
     664        _seedMesh = NULL;
     665    }
    621666    if (_streamTracer != NULL) {
    622667        // Set up seed source object
     
    667712    if (numPoints < 2)
    668713        return;
     714    _seedType = RAKE;
     715    _seedMesh = NULL;
    669716    if (_streamTracer != NULL) {
    670717        // Set up seed source object
     
    724771                                int numPoints)
    725772{
     773    _seedType = DISK;
     774    _seedMesh = NULL;
    726775    if (_streamTracer != NULL) {
    727776        // Set up seed source object
     
    816865                                   int numSides)
    817866{
     867    _seedType = POLYGON;
     868    _seedMesh = NULL;
    818869    if (_streamTracer != NULL) {
    819870        // Set up seed source object
     
    880931                                         int numPoints)
    881932{
     933    _seedType = FILLED_POLYGON;
     934    _seedMesh = NULL;
    882935    if (_streamTracer != NULL) {
    883936         // Set up seed source object
     
    11931246}
    11941247
    1195 void Streamlines::updateRanges(bool useCumulative,
    1196                                double scalarRange[2],
    1197                                double vectorMagnitudeRange[2],
    1198                                double vectorComponentRange[3][2])
    1199 {
    1200     if (useCumulative) {
    1201         _dataRange[0] = scalarRange[0];
    1202         _dataRange[1] = scalarRange[1];
    1203         _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
    1204         _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
     1248void Streamlines::updateRanges(Renderer *renderer)
     1249{
     1250    if (_dataSet == NULL) {
     1251        ERROR("called before setDataSet");
     1252        return;
     1253    }
     1254
     1255    if (renderer->getUseCumulativeRange()) {
     1256        renderer->getCumulativeDataRange(_dataRange,
     1257                                         _dataSet->getActiveScalarsName(),
     1258                                         1);
     1259        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
     1260                                         _dataSet->getActiveVectorsName(),
     1261                                         3);
    12051262        for (int i = 0; i < 3; i++) {
    1206             _vectorComponentRange[i][0] = vectorComponentRange[i][0];
    1207             _vectorComponentRange[i][1] = vectorComponentRange[i][1];
     1263            renderer->getCumulativeDataRange(_vectorComponentRange[i],
     1264                                             _dataSet->getActiveVectorsName(),
     1265                                             3, i);
    12081266        }
    12091267    } else {
     
    12161274
    12171275    // Need to update color map ranges and/or active vector field
    1218     setColorMode(_colorMode);
     1276    double *rangePtr = _colorFieldRange;
     1277    if (_colorFieldRange[0] > _colorFieldRange[1]) {
     1278        rangePtr = NULL;
     1279    }
     1280    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
    12191281}
    12201282
     
    12221284{
    12231285    _colorMode = mode;
     1286    if (_dataSet == NULL)
     1287        return;
     1288
     1289    switch (mode) {
     1290    case COLOR_BY_SCALAR:
     1291        setColorMode(mode,
     1292                     _dataSet->getActiveScalarsType(),
     1293                     _dataSet->getActiveScalarsName(),
     1294                     _dataRange);
     1295        break;
     1296    case COLOR_BY_VECTOR_MAGNITUDE:
     1297        setColorMode(mode,
     1298                     _dataSet->getActiveVectorsType(),
     1299                     _dataSet->getActiveVectorsName(),
     1300                     _vectorMagnitudeRange);
     1301        break;
     1302    case COLOR_BY_VECTOR_X:
     1303        setColorMode(mode,
     1304                     _dataSet->getActiveVectorsType(),
     1305                     _dataSet->getActiveVectorsName(),
     1306                     _vectorComponentRange[0]);
     1307        break;
     1308    case COLOR_BY_VECTOR_Y:
     1309        setColorMode(mode,
     1310                     _dataSet->getActiveVectorsType(),
     1311                     _dataSet->getActiveVectorsName(),
     1312                     _vectorComponentRange[1]);
     1313        break;
     1314    case COLOR_BY_VECTOR_Z:
     1315        setColorMode(mode,
     1316                     _dataSet->getActiveVectorsType(),
     1317                     _dataSet->getActiveVectorsName(),
     1318                     _vectorComponentRange[2]);
     1319        break;
     1320    case COLOR_CONSTANT:
     1321    default:
     1322        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
     1323        break;
     1324    }
     1325}
     1326
     1327void Streamlines::setColorMode(ColorMode mode,
     1328                               const char *name, double range[2])
     1329{
     1330    if (_dataSet == NULL)
     1331        return;
     1332    DataSet::DataAttributeType type = DataSet::POINT_DATA;
     1333    int numComponents = 1;
     1334    if (name != NULL && strlen(name) > 0 &&
     1335        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
     1336        ERROR("Field not found: %s", name);
     1337        return;
     1338    }
     1339    setColorMode(mode, type, name, range);
     1340}
     1341
     1342void Streamlines::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     1343                               const char *name, double range[2])
     1344{
     1345    _colorMode = mode;
     1346    _colorFieldType = type;
     1347    if (name == NULL)
     1348        _colorFieldName.clear();
     1349    else
     1350        _colorFieldName = name;
     1351    if (range == NULL) {
     1352        _colorFieldRange[0] = DBL_MAX;
     1353        _colorFieldRange[1] = -DBL_MAX;
     1354    } else {
     1355        memcpy(_colorFieldRange, range, sizeof(double)*2);
     1356    }
     1357
    12241358    if (_dataSet == NULL || _pdMapper == NULL)
    12251359        return;
    12261360
     1361    switch (type) {
     1362    case DataSet::POINT_DATA:
     1363        _pdMapper->SetScalarModeToUsePointFieldData();
     1364        break;
     1365    case DataSet::CELL_DATA:
     1366        _pdMapper->SetScalarModeToUseCellFieldData();
     1367        break;
     1368    default:
     1369        ERROR("Unsupported DataAttributeType: %d", type);
     1370        return;
     1371    }
     1372
     1373    if (name != NULL && strlen(name) > 0) {
     1374        _pdMapper->SelectColorArray(name);
     1375    } else {
     1376        _pdMapper->SetScalarModeToDefault();
     1377    }
     1378
     1379    if (_lut != NULL) {
     1380        if (range != NULL) {
     1381            _lut->SetRange(range);
     1382        } else if (name != NULL && strlen(name) > 0) {
     1383            double r[2];
     1384            int comp = -1;
     1385            if (mode == COLOR_BY_VECTOR_X)
     1386                comp = 0;
     1387            else if (mode == COLOR_BY_VECTOR_Y)
     1388                comp = 1;
     1389            else if (mode == COLOR_BY_VECTOR_Z)
     1390                comp = 2;
     1391
     1392            if (_renderer->getUseCumulativeRange()) {
     1393                int numComponents;
     1394                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
     1395                    ERROR("Field not found: %s, type: %d", name, type);
     1396                    return;
     1397                } else if (numComponents < comp+1) {
     1398                    ERROR("Request for component %d in field with %d components",
     1399                          comp, numComponents);
     1400                    return;
     1401                }
     1402                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
     1403            } else {
     1404                _dataSet->getDataRange(r, name, type, comp);
     1405            }
     1406            _lut->SetRange(r);
     1407        }
     1408    }
     1409
    12271410    switch (mode) {
    1228     case COLOR_BY_SCALAR: {
     1411    case COLOR_BY_SCALAR:
    12291412        _pdMapper->ScalarVisibilityOn();
    1230         _pdMapper->SetScalarModeToDefault();
     1413        break;
     1414    case COLOR_BY_VECTOR_MAGNITUDE:
     1415        _pdMapper->ScalarVisibilityOn();
    12311416        if (_lut != NULL) {
    1232             _lut->SetRange(_dataRange);
    1233         }
    1234     }
    1235         break;
    1236     case COLOR_BY_VECTOR_MAGNITUDE: {
    1237         _pdMapper->ScalarVisibilityOn();
    1238         _pdMapper->SetScalarModeToUsePointFieldData();
    1239         _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
    1240         if (_lut != NULL) {
    1241             _lut->SetRange(_vectorMagnitudeRange);
    12421417            _lut->SetVectorModeToMagnitude();
    12431418        }
    1244     }
    12451419        break;
    12461420    case COLOR_BY_VECTOR_X:
    12471421        _pdMapper->ScalarVisibilityOn();
    1248         _pdMapper->SetScalarModeToUsePointFieldData();
    1249         _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
    12501422        if (_lut != NULL) {
    1251             _lut->SetRange(_vectorComponentRange[0]);
    12521423            _lut->SetVectorModeToComponent();
    12531424            _lut->SetVectorComponent(0);
     
    12561427    case COLOR_BY_VECTOR_Y:
    12571428        _pdMapper->ScalarVisibilityOn();
    1258         _pdMapper->SetScalarModeToUsePointFieldData();
    1259         _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
    12601429        if (_lut != NULL) {
    1261             _lut->SetRange(_vectorComponentRange[1]);
    12621430            _lut->SetVectorModeToComponent();
    12631431            _lut->SetVectorComponent(1);
     
    12661434    case COLOR_BY_VECTOR_Z:
    12671435        _pdMapper->ScalarVisibilityOn();
    1268         _pdMapper->SetScalarModeToUsePointFieldData();
    1269         _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
    12701436        if (_lut != NULL) {
    1271             _lut->SetRange(_vectorComponentRange[2]);
    12721437            _lut->SetVectorModeToComponent();
    12731438            _lut->SetVectorComponent(2);
     
    13051470            _pdMapper->SetLookupTable(_lut);
    13061471        }
    1307     }
    1308 
    1309     _lut->DeepCopy(cmap->getLookupTable());
     1472        _lut->DeepCopy(cmap->getLookupTable());
     1473        switch (_colorMode) {
     1474        case COLOR_CONSTANT:
     1475        case COLOR_BY_SCALAR:
     1476            _lut->SetRange(_dataRange);
     1477            break;
     1478        case COLOR_BY_VECTOR_MAGNITUDE:
     1479            _lut->SetRange(_vectorMagnitudeRange);
     1480            break;
     1481        case COLOR_BY_VECTOR_X:
     1482            _lut->SetRange(_vectorComponentRange[0]);
     1483            break;
     1484        case COLOR_BY_VECTOR_Y:
     1485            _lut->SetRange(_vectorComponentRange[1]);
     1486            break;
     1487        case COLOR_BY_VECTOR_Z:
     1488            _lut->SetRange(_vectorComponentRange[2]);
     1489            break;
     1490        default:
     1491            break;
     1492        }
     1493    } else {
     1494        double range[2];
     1495        _lut->GetTableRange(range);
     1496        _lut->DeepCopy(cmap->getLookupTable());
     1497        _lut->SetRange(range);
     1498    }
    13101499
    13111500    switch (_colorMode) {
    1312     case COLOR_CONSTANT:
    1313     case COLOR_BY_SCALAR:
    1314         _lut->SetRange(_dataRange);
    1315         break;
    13161501    case COLOR_BY_VECTOR_MAGNITUDE:
    13171502        _lut->SetVectorModeToMagnitude();
    1318         _lut->SetRange(_vectorMagnitudeRange);
    13191503        break;
    13201504    case COLOR_BY_VECTOR_X:
    13211505        _lut->SetVectorModeToComponent();
    13221506        _lut->SetVectorComponent(0);
    1323         _lut->SetRange(_vectorComponentRange[0]);
    13241507        break;
    13251508    case COLOR_BY_VECTOR_Y:
    13261509        _lut->SetVectorModeToComponent();
    13271510        _lut->SetVectorComponent(1);
    1328         _lut->SetRange(_vectorComponentRange[1]);
    13291511        break;
    13301512    case COLOR_BY_VECTOR_Z:
    13311513        _lut->SetVectorModeToComponent();
    13321514        _lut->SetVectorComponent(2);
    1333         _lut->SetRange(_vectorComponentRange[2]);
    13341515        break;
    13351516    default:
  • branches/blt4/packages/vizservers/vtkvis/RpStreamlines.h

    r2550 r2681  
    2020#include "ColorMap.h"
    2121#include "RpVtkGraphicsObject.h"
     22#include "RpVtkDataSet.h"
    2223
    2324namespace Rappture {
     
    5859        BOTH
    5960    };
     61    enum SeedType {
     62        DATASET_MESH_POINTS,
     63        DATASET_FILLED_MESH,
     64        MESH_POINTS,
     65        FILLED_MESH,
     66        RAKE,
     67        DISK,
     68        POLYGON,
     69        FILLED_POLYGON
     70    };
    6071
    6172    Streamlines();
     
    6879
    6980    virtual void setDataSet(DataSet *dataSet,
    70                             bool useCumulative,
    71                             double scalarRange[2],
    72                             double vectorMagnitudeRange[2],
    73                             double vectorComponentRange[3][2]);
     81                            Renderer *renderer);
    7482
    7583    virtual void setLighting(bool state);
     
    9098
    9199    virtual void setClippingPlanes(vtkPlaneCollection *planes);
     100
     101    void setNumberOfSeedPoints(int numPoints);
    92102
    93103    void setSeedToMeshPoints();
     
    137147
    138148    void setLineTypeToRibbons(double width, double angle);
     149
     150    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
     151                      const char *name, double range[2] = NULL);
     152
     153    void setColorMode(ColorMode mode,
     154                      const char *name, double range[2] = NULL);
    139155
    140156    void setColorMode(ColorMode mode);
     
    152168    void updateColorMap();
    153169
    154     virtual void updateRanges(bool useCumulative,
    155                               double scalarRange[2],
    156                               double vectorMagnitudeRange[2],
    157                               double vectorComponentRange[3][2]);
     170    virtual void updateRanges(Renderer *renderer);
    158171
    159172    void setSeedVisibility(bool state);
     
    182195
    183196    LineType _lineType;
     197    ColorMap *_colorMap;
    184198    ColorMode _colorMode;
    185     ColorMap *_colorMap;
     199    std::string _colorFieldName;
     200    DataSet::DataAttributeType _colorFieldType;
     201    double _colorFieldRange[2];
     202    SeedType _seedType;
    186203    float _seedColor[3];
    187204    bool _seedVisible;
    188205    double _vectorMagnitudeRange[2];
    189206    double _vectorComponentRange[3][2];
     207    Renderer *_renderer;
    190208    double _dataScale;
    191209
     
    193211    vtkSmartPointer<vtkActor> _linesActor;
    194212    vtkSmartPointer<vtkActor> _seedActor;
     213    vtkSmartPointer<vtkDataSet> _seedMesh;
    195214    vtkSmartPointer<vtkStreamTracer> _streamTracer;
    196215    vtkSmartPointer<vtkPolyDataAlgorithm> _lineFilter;
  • branches/blt4/packages/vizservers/vtkvis/RpVolume.cpp

    r2542 r2681  
    116116}
    117117
    118 void Volume::updateRanges(bool useCumulative,
    119                           double scalarRange[2],
    120                           double vectorMagnitudeRange[2],
    121                           double vectorComponentRange[3][2])
     118void Volume::updateRanges(Renderer *renderer)
    122119{
    123     if (useCumulative) {
    124         _dataRange[0] = scalarRange[0];
    125         _dataRange[1] = scalarRange[1];
    126     } else if (_dataSet != NULL) {
    127         _dataSet->getScalarRange(_dataRange);
    128     }
     120    VtkGraphicsObject::updateRanges(renderer);
    129121
    130122    if (getVolume() != NULL) {
     
    133125    }
    134126}
     127
    135128void Volume::updateColorMap()
    136129{
     
    143136void Volume::setColorMap(ColorMap *cmap)
    144137{
     138    if (cmap == NULL)
     139        return;
     140
    145141    _colorMap = cmap;
    146142
  • branches/blt4/packages/vizservers/vtkvis/RpVolume.h

    r2542 r2681  
    5353    void updateColorMap();
    5454
    55     virtual void updateRanges(bool useCumulative,
    56                               double scalarRange[2],
    57                               double vectorMagnitudeRange[2],
    58                               double vectorComponentRange[3][2]);
     55    virtual void updateRanges(Renderer *renderer);
    5956
    6057private:
  • branches/blt4/packages/vizservers/vtkvis/RpVtkDataSet.cpp

    r2542 r2681  
    411411 * and if so, returns the plane normal and offset from origin
    412412 */
    413 bool DataSet::is2D(DataSet::PrincipalPlane *plane, double *offset) const
     413bool DataSet::is2D(PrincipalPlane *plane, double *offset) const
    414414{
    415415    double bounds[6];
     
    447447 * largest two dimensions of the AABB
    448448 */
    449 DataSet::PrincipalPlane DataSet::principalPlane() const
     449PrincipalPlane DataSet::principalPlane() const
    450450{
    451451    double bounds[6];
     
    529529 * \brief Get the active scalar array field name
    530530 */
    531 const char *DataSet::getActiveScalarsName()
     531const char *DataSet::getActiveScalarsName() const
    532532{
    533533    if (_dataSet != NULL) {
     
    544544    }
    545545    return NULL;
     546}
     547
     548/**
     549 * \brief Get the active scalar array default attribute type
     550 */
     551DataSet::DataAttributeType DataSet::getActiveScalarsType() const
     552{
     553    if (_dataSet != NULL) {
     554         if (_dataSet->GetPointData() != NULL &&
     555             _dataSet->GetPointData()->GetScalars() != NULL) {
     556            return POINT_DATA;
     557        }
     558        TRACE("No point scalars");
     559        if (_dataSet->GetCellData() != NULL &&
     560            _dataSet->GetCellData()->GetScalars() != NULL) {
     561            return CELL_DATA;
     562        }
     563        TRACE("No cell scalars");
     564    }
     565    return POINT_DATA;
    546566}
    547567
     
    571591
    572592/**
     593 * \brief Get the active vector array default attribute type
     594 */
     595DataSet::DataAttributeType DataSet::getActiveVectorsType() const
     596{
     597    if (_dataSet != NULL) {
     598         if (_dataSet->GetPointData() != NULL &&
     599             _dataSet->GetPointData()->GetVectors() != NULL) {
     600            return POINT_DATA;
     601        }
     602        TRACE("No point vectors");
     603        if (_dataSet->GetCellData() != NULL &&
     604            _dataSet->GetCellData()->GetVectors() != NULL) {
     605            return CELL_DATA;
     606        }
     607        TRACE("No cell vectors");
     608    }
     609    return POINT_DATA;
     610}
     611
     612/**
    573613 * \brief Get the active vector array field name
    574614 */
    575 const char *DataSet::getActiveVectorsName()
     615const char *DataSet::getActiveVectorsName() const
    576616{
    577617    if (_dataSet != NULL) {
     
    588628    }
    589629    return NULL;
     630}
     631
     632bool DataSet::getFieldInfo(const char *fieldName,
     633                           DataAttributeType *type,
     634                           int *numComponents) const
     635{
     636    if (_dataSet->GetPointData() != NULL &&
     637        _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
     638        if (type != NULL)
     639            *type = POINT_DATA;
     640        if (numComponents != NULL)
     641            *numComponents = _dataSet->GetPointData()->GetArray(fieldName)->GetNumberOfComponents();
     642        return true;
     643    } else if (_dataSet->GetCellData() != NULL &&
     644               _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
     645        if (type != NULL)
     646            *type = CELL_DATA;
     647        if (numComponents != NULL)
     648            *numComponents = _dataSet->GetCellData()->GetArray(fieldName)->GetNumberOfComponents();
     649        return true;
     650    } else if (_dataSet->GetFieldData() != NULL &&
     651               _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
     652        if (type != NULL)
     653            *type = FIELD_DATA;
     654        if (numComponents != NULL)
     655            *numComponents = _dataSet->GetFieldData()->GetArray(fieldName)->GetNumberOfComponents();
     656        return true;
     657    }
     658    return false;
     659}
     660
     661bool DataSet::getFieldInfo(const char *fieldName,
     662                           DataAttributeType type,
     663                           int *numComponents) const
     664{
     665    switch (type) {
     666    case POINT_DATA:
     667        if (_dataSet->GetPointData() != NULL &&
     668            _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
     669            if (numComponents != NULL)
     670                *numComponents = _dataSet->GetPointData()->GetArray(fieldName)->GetNumberOfComponents();
     671            return true;
     672        } else
     673            return false;
     674        break;
     675    case CELL_DATA:
     676        if (_dataSet->GetCellData() != NULL &&
     677            _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
     678            if (numComponents != NULL)
     679                *numComponents = _dataSet->GetCellData()->GetArray(fieldName)->GetNumberOfComponents();
     680            return true;
     681        } else
     682            return false;
     683        break;
     684    case FIELD_DATA:
     685        if (_dataSet->GetFieldData() != NULL &&
     686            _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
     687            if (numComponents != NULL)
     688                *numComponents = _dataSet->GetFieldData()->GetArray(fieldName)->GetNumberOfComponents();
     689            return true;
     690        } else
     691            return false;
     692        break;
     693    default:
     694        ;
     695    }
     696    return false;
     697}
     698
     699/**
     700 * \brief Get the list of field names in the DataSet
     701 *
     702 * \param[in,out] names The field names will be appended to this list
     703 * \param[in] type The DataAttributeType: e.g. POINT_DATA, CELL_DATA
     704 * \param[in] numComponents Filter list by number of components, -1 means to
     705 * return all fields regardless of dimension
     706 */
     707void DataSet::getFieldNames(std::vector<std::string>& names,
     708                            DataAttributeType type, int numComponents) const
     709{
     710    if (_dataSet == NULL)
     711        return;
     712    switch (type) {
     713    case POINT_DATA:
     714        if (_dataSet->GetPointData() != NULL) {
     715            for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
     716                if (numComponents == -1 ||
     717                    _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
     718                    names.push_back(_dataSet->GetPointData()->GetArrayName(i));
     719                }
     720            }
     721        }
     722        break;
     723    case CELL_DATA:
     724        if (_dataSet->GetCellData() != NULL) {
     725            for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
     726                if (numComponents == -1 ||
     727                    _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
     728                    names.push_back(_dataSet->GetCellData()->GetArrayName(i));
     729                }
     730            }
     731        }
     732        break;
     733    case FIELD_DATA:
     734        if (_dataSet->GetFieldData() != NULL) {
     735            for (int i = 0; i < _dataSet->GetFieldData()->GetNumberOfArrays(); i++) {
     736                if (numComponents == -1 ||
     737                    _dataSet->GetFieldData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
     738                    names.push_back(_dataSet->GetFieldData()->GetArrayName(i));
     739                }
     740            }
     741        }
     742        break;
     743    default:
     744        ERROR("Unknown DataAttributeType %d", type);
     745    }
    590746}
    591747
     
    630786 * \param[out] minmax The data range
    631787 * \param[in] fieldName The array name
     788 * \param[in] type The DataAttributeType
    632789 * \param[in] component The field component, -1 means magnitude
    633  */
    634 void DataSet::getDataRange(double minmax[2], const char *fieldName, int component) const
     790 * \return boolean indicating if field was found
     791 */
     792bool DataSet::getDataRange(double minmax[2], const char *fieldName,
     793                           DataAttributeType type, int component) const
    635794{
    636795    if (_dataSet == NULL)
    637         return;
    638     if (_dataSet->GetPointData() != NULL &&
    639         _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
    640         _dataSet->GetPointData()->GetArray(fieldName)->GetRange(minmax, component);
    641     } else if (_dataSet->GetCellData() != NULL &&
    642         _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
    643         _dataSet->GetCellData()->GetArray(fieldName)->GetRange(minmax, component);
    644     } else if (_dataSet->GetFieldData() != NULL &&
    645         _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
    646         _dataSet->GetFieldData()->GetArray(fieldName)->GetRange(minmax, component);
    647     }
     796        return false;
     797    switch (type) {
     798    case POINT_DATA:
     799        if (_dataSet->GetPointData() != NULL &&
     800            _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
     801            _dataSet->GetPointData()->GetArray(fieldName)->GetRange(minmax, component);
     802            return true;
     803        } else {
     804            return false;
     805        }
     806        break;
     807    case CELL_DATA:
     808        if (_dataSet->GetCellData() != NULL &&
     809            _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
     810            _dataSet->GetCellData()->GetArray(fieldName)->GetRange(minmax, component);
     811            return true;
     812        } else {
     813            return false;
     814        }
     815        break;
     816    case FIELD_DATA:
     817        if (_dataSet->GetFieldData() != NULL &&
     818            _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
     819            _dataSet->GetFieldData()->GetArray(fieldName)->GetRange(minmax, component);
     820            return true;
     821        } else {
     822            return false;
     823        }
     824        break;
     825    default:
     826        ERROR("Unknown DataAttributeType %d", type);
     827        break;
     828    }
     829    return false;
    648830}
    649831
     
    706888 * Note: no interpolation is performed on data
    707889 *
    708  * \return the value of the nearest point or 0 if no scalar data available
     890 * \param[in] x World x coordinate to probe
     891 * \param[in] y World y coordinate to probe
     892 * \param[in] z World z coordinate to probe
     893 * \param[out] value On success, contains the data value
     894 * \return boolean indicating success or failure
    709895 */
    710896bool DataSet::getScalarValue(double x, double y, double z, double *value) const
  • branches/blt4/packages/vizservers/vtkvis/RpVtkDataSet.h

    r2542 r2681  
    2020#include <vector>
    2121
     22#include "RpTypes.h"
     23
    2224namespace Rappture {
    2325namespace VtkVis {
     
    2830class DataSet {
    2931public:
    30     enum PrincipalPlane {
    31         PLANE_XY,
    32         PLANE_ZY,
    33         PLANE_XZ
     32    enum DataAttributeType {
     33        POINT_DATA,
     34        CELL_DATA,
     35        FIELD_DATA
    3436    };
    3537    DataSet(const std::string& name);
     
    6264    bool setActiveScalars(const char *name);
    6365
    64     const char *getActiveScalarsName();
     66    const char *getActiveScalarsName() const;
     67
     68    DataAttributeType getActiveScalarsType() const;
    6569
    6670    bool setActiveVectors(const char *name);
    6771
    68     const char *getActiveVectorsName();
     72    const char *getActiveVectorsName() const;
     73
     74    DataAttributeType getActiveVectorsType() const;
     75
     76    bool hasField(const char *fieldName) const
     77    {
     78        return getFieldInfo(fieldName, NULL, NULL);
     79    }
     80
     81    bool hasField(const char *fieldName, DataAttributeType type) const
     82    {
     83        return getFieldInfo(fieldName, type, NULL);
     84    }
     85
     86    bool getFieldInfo(const char *fieldName, DataAttributeType *type, int *numComponents) const;
     87
     88    bool getFieldInfo(const char *fieldName, DataAttributeType type, int *numComponents) const;
     89
     90    void getFieldNames(std::vector<std::string>& names,
     91                       DataAttributeType type, int numComponents = -1) const;
     92
     93    bool getDataRange(double minmax[2], const char *fieldName,
     94                      DataAttributeType type, int component = -1) const;
    6995
    7096    void getScalarRange(double minmax[2]) const;
    71 
    72     void getDataRange(double minmax[2], const char *fieldName, int component = -1) const;
    7397
    7498    void getVectorRange(double minmax[2], int component = -1) const;
  • branches/blt4/packages/vizservers/vtkvis/RpVtkGraphicsObject.h

    r2542 r2681  
    3131namespace VtkVis {
    3232
     33class Renderer;
     34
    3335/**
    3436 * \brief Base class for graphics objects
     
    9294     *
    9395     * \param[in] dataSet DataSet to use in rendering
    94      * \param[in] useCumulative Whether the cumulative data ranges should be
    95      * used in place of the dataSet's ranges
    96      * \param[in] scalarRange Current cumulative scalar data range
    97      * \param[in] vectorMagnitudeRange Current cumulative vector magnitude data range
    98      * \param[in] vectorComponentRange Current cumulative vector component data ranges
     96     * \param[in] renderer Pointer to Renderer -- may be used to get
     97     * cumulative data ranges
    9998     */
    10099    virtual void setDataSet(DataSet *dataSet,
    101                             bool useCumulative,
    102                             double scalarRange[2],
    103                             double vectorMagnitudeRange[2],
    104                             double vectorComponentRange[3][2])
    105     {
    106         if (_dataSet != dataSet) {
    107             _dataSet = dataSet;
    108 
    109             if (useCumulative) {
    110                 _dataRange[0] = scalarRange[0];
    111                 _dataRange[1] = scalarRange[1];
    112             } else {
    113                 _dataSet->getScalarRange(_dataRange);
    114             }
    115 
    116             update();
    117         }
    118     }
     100                            Renderer *renderer);
    119101
    120102    /**
     
    122104     * cumulative ranges or settings change
    123105     *
    124      * \param[in] useCumulative Whether the cumulative data ranges should be
    125      * used in place of the dataSet's ranges
    126      * \param[in] scalarRange Current cumulative scalar data range
    127      * \param[in] vectorMagnitudeRange Current cumulative vector magnitude data range
    128      * \param[in] vectorComponentRange Current cumulative vector component data ranges
    129      */
    130     virtual void updateRanges(bool useCumulative,
    131                               double scalarRange[2],
    132                               double vectorMagnitudeRange[2],
    133                               double vectorComponentRange[3][2])
    134     {
    135         if (useCumulative) {
    136             _dataRange[0] = scalarRange[0];
    137             _dataRange[1] = scalarRange[1];
    138         } else {
    139             _dataSet->getScalarRange(_dataRange);
    140         }
    141     }
     106     * \param[in] renderer Pointer to Renderer -- may be used to get
     107     * cumulative data ranges
     108     */
     109    virtual void updateRanges(Renderer *renderer);
    142110
    143111    /**
     
    730698            property->SetPointSize(_pointSize);
    731699            property->EdgeVisibilityOff();
     700            if (_dataSet != NULL)
     701                _opacity = _dataSet->getOpacity();
    732702            property->SetOpacity(_opacity);
    733703            property->SetAmbient(.2);
     
    737707                setCulling(property, true);
    738708            }
     709            if (_dataSet != NULL)
     710                setVisibility(_dataSet->getVisibility());
    739711        }
    740712    }
  • branches/blt4/packages/vizservers/vtkvis/RpVtkRenderServer.cpp

    r2550 r2681  
    99#include <cstring>
    1010#include <cstdlib>
    11 #include <string>
    12 #include <sstream>
     11#include <cerrno>
    1312#include <unistd.h>
    1413#include <signal.h>
     
    1817#endif
    1918
     19#include <string>
     20#include <sstream>
     21
    2022#include "Trace.h"
     23#include "ReadBuffer.h"
    2124#include "RpVtkRenderServer.h"
    2225#include "RpVtkRendererCmd.h"
     
    2427#include "PPMWriter.h"
    2528#include "TGAWriter.h"
     29#ifdef USE_THREADS
     30#include <pthread.h>
     31#include "ResponseQueue.h"
     32#endif
    2633
    2734using namespace Rappture::VtkVis;
     
    2936int Rappture::VtkVis::g_fdIn = STDIN_FILENO; ///< Input file descriptor
    3037int Rappture::VtkVis::g_fdOut = STDOUT_FILENO; ///< Output file descriptor
    31 FILE *Rappture::VtkVis::g_fIn = stdin; ///< Input file handle
    3238FILE *Rappture::VtkVis::g_fOut = stdout; ///< Output file handle
    3339FILE *Rappture::VtkVis::g_fLog = NULL; ///< Trace logging file handle
    3440Renderer *Rappture::VtkVis::g_renderer = NULL; ///< Main render worker
     41ReadBuffer *Rappture::VtkVis::g_inBufPtr = NULL; ///< Socket read buffer
    3542
    3643#define ELAPSED_TIME(t1, t2) \
     
    3845     (((t2).tv_sec - (t1).tv_sec))*1.0e+3f + (float)((t2).tv_usec - (t1).tv_usec)/1.0e+3f)
    3946
     47#ifdef USE_THREADS
    4048static void
    41 writeFrame(int fd, vtkUnsignedCharArray *imgData)
     49queueFrame(ResponseQueue *queue, vtkUnsignedCharArray *imgData)
    4250{
    4351#ifdef DEBUG
     
    6573                 TARGA_BYTES_PER_PIXEL,
    6674                 true);
    67 #endif
     75#endif  /*RENDER_TARGA*/
    6876
    6977#else
     
    8290
    8391#ifdef RENDER_TARGA
     92        queueTGA(queue, oss.str().c_str(),
     93                 imgData->GetPointer(0),
     94                 g_renderer->getWindowWidth(),
     95                 g_renderer->getWindowHeight(),
     96                 TARGA_BYTES_PER_PIXEL);
     97#else
     98        queuePPM(queue, oss.str().c_str(),
     99                 imgData->GetPointer(0),
     100                 g_renderer->getWindowWidth(),
     101                 g_renderer->getWindowHeight());
     102#endif  /*RENDER_TARGA*/
     103    } else {
     104#ifdef RENDER_TARGA
     105        queueTGA(queue, "nv>image -type image -bytes",
     106                 imgData->GetPointer(0),
     107                 g_renderer->getWindowWidth(),
     108                 g_renderer->getWindowHeight(),
     109                 TARGA_BYTES_PER_PIXEL);
     110#else
     111        queuePPM(queue, "nv>image -type image -bytes",
     112                 imgData->GetPointer(0),
     113                 g_renderer->getWindowWidth(),
     114                 g_renderer->getWindowHeight());
     115#endif  /*RENDER_TARGA*/
     116    }
     117#endif  /*DEBUG*/
     118}
     119
     120#else
     121
     122static void
     123writeFrame(int fd, vtkUnsignedCharArray *imgData)
     124{
     125#ifdef DEBUG
     126    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
     127        double xywh[4];
     128        g_renderer->getScreenWorldCoords(xywh);
     129        TRACE("Image bbox: %g %g %g %g",
     130              xywh[0],
     131              (xywh[1] + xywh[3]),
     132              (xywh[0] + xywh[2]),
     133              xywh[1]);
     134    }
     135
     136#ifdef RENDER_TARGA
     137    writeTGAFile("/tmp/frame.tga",
     138                 imgData->GetPointer(0),
     139                 g_renderer->getWindowWidth(),
     140                 g_renderer->getWindowHeight(),
     141                 TARGA_BYTES_PER_PIXEL);
     142#else
     143    writeTGAFile("/tmp/frame.tga",
     144                 imgData->GetPointer(0),
     145                 g_renderer->getWindowWidth(),
     146                 g_renderer->getWindowHeight(),
     147                 TARGA_BYTES_PER_PIXEL,
     148                 true);
     149#endif  /*RENDER_TARGA*/
     150
     151#else
     152    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
     153        double xywh[4];
     154        g_renderer->getCameraZoomRegion(xywh);
     155        std::ostringstream oss;
     156        oss.precision(12);
     157        // Send upper left and lower right corners as bbox
     158        oss << "nv>image -type image -bbox {"
     159            << std::scientific
     160            << xywh[0] << " "
     161            << xywh[1] << " "
     162            << xywh[2] << " "
     163            << xywh[3] << "} -bytes";
     164
     165#ifdef RENDER_TARGA
    84166        writeTGA(fd, oss.str().c_str(),
    85167                 imgData->GetPointer(0),
     
    92174                 g_renderer->getWindowWidth(),
    93175                 g_renderer->getWindowHeight());
    94 #endif
     176#endif  /*RENDER_TARGA*/
    95177    } else {
    96178#ifdef RENDER_TARGA
     
    105187                 g_renderer->getWindowWidth(),
    106188                 g_renderer->getWindowHeight());
    107 #endif
    108     }
    109 #endif
    110 }
     189#endif  /*RENDER_TARGA*/
     190    }
     191#endif  /*DEBUG*/
     192}
     193#endif /*USE_THREADS*/
    111194
    112195static void
     
    153236}
    154237
     238#ifdef USE_THREADS
     239static void *
     240readerThread(void *clientData)
     241{
     242    ResponseQueue *queue = (ResponseQueue *)clientData;
     243    Tcl_Interp *interp;
     244
     245    TRACE("Starting reader thread");
     246    interp = (Tcl_Interp *)queue->clientData();
     247    vtkSmartPointer<vtkUnsignedCharArray> imgData =
     248        vtkSmartPointer<vtkUnsignedCharArray>::New();
     249    for (;;) {
     250        if (processCommands(interp, g_inBufPtr, g_fdOut) < 0)
     251            break;
     252
     253        if (g_renderer->render()) {
     254            TRACE("Rendering new frame");
     255            g