| 
    Volume Cartographer 2.28.0
    
   | 
 
Generate a Texture by taking the discrete integral (summation) of the neighborhood adjacent to a point. More...
#include <vc/texturing/IntegralTexture.hpp>
Public Types | |
| enum class | WeightMethod { None = 0 , Linear , ExpoDiff } | 
| Weighting Methods.  More... | |
| enum class | LinearWeightDirection { Positive = 0 , Negative } | 
| Linear weight direction.  More... | |
| enum class | ExpoDiffBaseMethod { Mean = 0 , Mode , Manual } | 
| Exponential difference base calculation method.  More... | |
  Public Types inherited from volcart::texturing::TexturingAlgorithm | |
| using | Pointer = std::shared_ptr< TexturingAlgorithm > | 
| using | Texture = std::vector< cv::Mat > | 
Public Member Functions | |
| void | setGenerator (NeighborhoodGenerator::Pointer g) | 
| Set the Neighborhood generator.  More... | |
| void | setClampValuesToMax (bool b) | 
| When enabled, clamp neighborhood intensities to the value specified by setClampMax()  More... | |
| auto | clampValuesToMax () const -> bool | 
| When enabled, clamp neighborhood intensities to the value specified by setClampMax()  More... | |
| void | setClampMax (std::uint16_t m) | 
| The maximum intensity value allowed in neighborhood prior to integration.  More... | |
| auto | clampMax () const -> std::uint16_t | 
| The maximum intensity value allowed in neighborhood prior to integration.  More... | |
| void | setWeightMethod (WeightMethod w) | 
| Set the weighting method.  More... | |
| auto | weightMethod () const -> WeightMethod | 
| Set the weighting method.  More... | |
| void | setLinearWeightDirection (LinearWeightDirection w) | 
| Set the linear weight direction.  More... | |
| auto | linearWeightDirection () const -> LinearWeightDirection | 
| Set the linear weight direction.  More... | |
| void | setExponentialDiffExponent (int e) | 
| Set the weighting exponent used by Exponential Difference weighting.  | |
| auto | exponentialDiffExponent () const -> int | 
| Set the weighting exponent used by Exponential Difference weighting.  More... | |
| void | setExponentialDiffBaseMethod (ExpoDiffBaseMethod m) | 
| Set the method used to calculate the Exponential Difference base value.  More... | |
| auto | exponentialDiffBaseMethod () const -> ExpoDiffBaseMethod | 
| Set the method used to calculate the Exponential Difference base value.  More... | |
| void | setExponentialDiffBaseValue (double b) | 
| Set the base value for Exponential Difference weighting.  | |
| auto | exponentialDiffBaseValue () const -> double | 
| Set the base value for Exponential Difference weighting.  More... | |
| void | setExponentialDiffSuppressBelowBase (bool b) | 
| When enabled, do not integrate intensity values below the base value.  More... | |
| auto | exponentialDiffSuppressBelowBase () const -> bool | 
| When enabled, do not integrate intensity values below the base value.  More... | |
| auto | compute () -> Texture override | 
| Compute the Texture.  More... | |
  Public Member Functions inherited from volcart::texturing::TexturingAlgorithm | |
| virtual | ~TexturingAlgorithm ()=default | 
| void | setPerPixelMap (PerPixelMap::Pointer ppm) | 
| Set the input PerPixelMap.  | |
| void | setVolume (Volume::Pointer vol) | 
| Set the input Volume.  | |
| virtual auto | compute () -> Texture=0 | 
| Compute the Texture.  More... | |
| auto | getTexture () -> Texture | 
| Get the generated Texture.  | |
| auto | progressIterations () const -> std::size_t override | 
| Returns the maximum progress value.  More... | |
| virtual std::size_t | progressIterations () const =0 | 
Private Member Functions | |
| void | setup_weights_ () | 
| auto | apply_weights_ (NDArray< double > &n) -> NDArray< double > | 
| void | setup_linear_weights_ () | 
| auto | apply_linear_weights_ (NDArray< double > &n) -> NDArray< double > | 
| void | setup_expodiff_weights_ () | 
| auto | expodiff_intersection_pts_ () -> std::vector< std::uint16_t > | 
| auto | expodiff_mean_base_ () -> double | 
| auto | expodiff_mode_base_ () -> double | 
| auto | apply_expodiff_weights_ (NDArray< double > &n) const -> NDArray< double > | 
Private Attributes | |
| NeighborhoodGenerator::Pointer | gen_ | 
| bool | clampToMax_ {false} | 
| std::uint16_t | clampMax_ {std::numeric_limits<uint16_t>::max()} | 
| WeightMethod | weight_ {WeightMethod::None} | 
| LinearWeightDirection | linearWeight_ {LinearWeightDirection::Positive} | 
| NDArray< double > | linearWeights_ {1} | 
| int | expoDiffExponent_ {2} | 
| ExpoDiffBaseMethod | expoDiffBaseMethod_ {ExpoDiffBaseMethod::Mean} | 
| double | expoDiffManualBase_ {0} | 
| double | expoDiffBase_ {0} | 
| bool | suppressBelowBase_ {true} | 
| using | Pointer = std::shared_ptr< IntegralTexture > | 
| static auto | New () -> Pointer | 
| IntegralTexture ()=default | |
| ~IntegralTexture () override=default | |
| IntegralTexture (IntegralTexture &)=default | |
| IntegralTexture (IntegralTexture &&)=default | |
| auto | operator= (const IntegralTexture &) -> IntegralTexture &=default | 
| auto | operator= (IntegralTexture &&) -> IntegralTexture &=default | 
Additional Inherited Members | |
  Public Attributes inherited from volcart::IterationsProgress | |
| Signal | progressStarted | 
| Signal< std::size_t > | progressUpdated | 
| Signal | progressComplete | 
  Protected Member Functions inherited from volcart::texturing::TexturingAlgorithm | |
| TexturingAlgorithm ()=default | |
| TexturingAlgorithm (TexturingAlgorithm &)=default | |
| TexturingAlgorithm (TexturingAlgorithm &&)=default | |
| auto | operator= (const TexturingAlgorithm &) -> TexturingAlgorithm &=default | 
| auto | operator= (TexturingAlgorithm &&) -> TexturingAlgorithm &=default | 
  Protected Attributes inherited from volcart::texturing::TexturingAlgorithm | |
| PerPixelMap::Pointer | ppm_ | 
| Volume::Pointer | vol_ | 
| Texture | result_ | 
Generate a Texture by taking the discrete integral (summation) of the neighborhood adjacent to a point.
Definition at line 18 of file IntegralTexture.hpp.
| using volcart::texturing::IntegralTexture::Pointer = std::shared_ptr<IntegralTexture> | 
Pointer type
Definition at line 59 of file IntegralTexture.hpp.
      
  | 
  strong | 
Exponential difference base calculation method.
The method by which the base value is calculated for Exponential Difference weighting:
Definition at line 55 of file IntegralTexture.hpp.
      
  | 
  strong | 
Linear weight direction.
Setting the weight option applies a linear weight factor to the intensity values of the neighborhood. The options are named according to which values along a point's surface normal are favored.
The weight factors for the options are as follows:
Definition at line 44 of file IntegralTexture.hpp.
      
  | 
  strong | 
Weighting Methods.
The method by which neighborhoods are weighted prior to integration:
Definition at line 31 of file IntegralTexture.hpp.
      
  | 
  default | 
Default constructor
      
  | 
  overridedefault | 
Default destructor
      
  | 
  default | 
Default copy constructor
      
  | 
  default | 
Default move constructor
      
  | 
  private | 
Apply the expo diff weights to a neighborhood
      
  | 
  private | 
Apply the linear weights vector to a neighborhood
      
  | 
  private | 
Apply the selected weighting method
| auto volcart::texturing::IntegralTexture::clampMax | ( | ) | const -> std::uint16_t | 
The maximum intensity value allowed in neighborhood prior to integration.
Ignored if setClampValuesToMax() is set to false
Default: std::numeric_limits<std::uint16_t>::max()
| auto volcart::texturing::IntegralTexture::clampValuesToMax | ( | ) | const -> bool | 
When enabled, clamp neighborhood intensities to the value specified by setClampMax()
Note: Clamping is performed prior to integration of the neighborhood
      
  | 
  overridevirtual | 
Compute the Texture.
Implements volcart::texturing::TexturingAlgorithm.
      
  | 
  private | 
Get the list of intensities on the surface of the mesh
      
  | 
  private | 
Calculate the mean base value
      
  | 
  private | 
Calculate the mode base value
| auto volcart::texturing::IntegralTexture::exponentialDiffBaseMethod | ( | ) | const -> ExpoDiffBaseMethod | 
Set the method used to calculate the Exponential Difference base value.
Default: Mean
| auto volcart::texturing::IntegralTexture::exponentialDiffBaseValue | ( | ) | const -> double | 
Set the base value for Exponential Difference weighting.
| auto volcart::texturing::IntegralTexture::exponentialDiffExponent | ( | ) | const -> int | 
Set the weighting exponent used by Exponential Difference weighting.
| auto volcart::texturing::IntegralTexture::exponentialDiffSuppressBelowBase | ( | ) | const -> bool | 
When enabled, do not integrate intensity values below the base value.
For exponential difference weighting only.
Default: True
| auto volcart::texturing::IntegralTexture::linearWeightDirection | ( | ) | const -> LinearWeightDirection | 
Set the linear weight direction.
Default: Positive
      
  | 
  static | 
Make shared pointer
      
  | 
  default | 
Default copy operator
      
  | 
  default | 
Default move operator
| void volcart::texturing::IntegralTexture::setClampMax | ( | std::uint16_t | m | ) | 
The maximum intensity value allowed in neighborhood prior to integration.
Ignored if setClampValuesToMax() is set to false
Default: std::numeric_limits<std::uint16_t>::max()
| void volcart::texturing::IntegralTexture::setClampValuesToMax | ( | bool | b | ) | 
When enabled, clamp neighborhood intensities to the value specified by setClampMax()
Note: Clamping is performed prior to integration of the neighborhood
| void volcart::texturing::IntegralTexture::setExponentialDiffBaseMethod | ( | ExpoDiffBaseMethod | m | ) | 
Set the method used to calculate the Exponential Difference base value.
Default: Mean
| void volcart::texturing::IntegralTexture::setExponentialDiffSuppressBelowBase | ( | bool | b | ) | 
When enabled, do not integrate intensity values below the base value.
For exponential difference weighting only.
Default: True
| void volcart::texturing::IntegralTexture::setGenerator | ( | NeighborhoodGenerator::Pointer | g | ) | 
Set the Neighborhood generator.
This class supports generators of dimension >= 1
| void volcart::texturing::IntegralTexture::setLinearWeightDirection | ( | LinearWeightDirection | w | ) | 
Set the linear weight direction.
Default: Positive
      
  | 
  private | 
Setup the expo diff weights
      
  | 
  private | 
Setup the linear weights vector
      
  | 
  private | 
Setup the selected weighting method
| void volcart::texturing::IntegralTexture::setWeightMethod | ( | WeightMethod | w | ) | 
Set the weighting method.
Default: None
| auto volcart::texturing::IntegralTexture::weightMethod | ( | ) | const -> WeightMethod | 
Set the weighting method.
Default: None
      
  | 
  private | 
Maximum allowed value in neighborhood when clamping is enabled
Definition at line 183 of file IntegralTexture.hpp.
      
  | 
  private | 
Enable/Disable clamping to maximum value
Definition at line 180 of file IntegralTexture.hpp.
      
  | 
  private | 
Exponential diff base value that is used
Definition at line 216 of file IntegralTexture.hpp.
      
  | 
  private | 
Exponential diff base calculation method
Definition at line 210 of file IntegralTexture.hpp.
      
  | 
  private | 
Exponential diff exponent
Definition at line 207 of file IntegralTexture.hpp.
      
  | 
  private | 
Manually specified exponential diff base
Definition at line 213 of file IntegralTexture.hpp.
      
  | 
  private | 
Neighborhood generator
Definition at line 177 of file IntegralTexture.hpp.
      
  | 
  private | 
Linear weighting direction
Definition at line 195 of file IntegralTexture.hpp.
      
  | 
  private | 
Linear weights vector
Definition at line 198 of file IntegralTexture.hpp.
      
  | 
  private | 
Whether or not to ignore values below the base value
Definition at line 219 of file IntegralTexture.hpp.
      
  | 
  private | 
Selected Weighting method
Definition at line 186 of file IntegralTexture.hpp.