MMF_TrapModeSmoothProduct

Note that this implimentation is slightly different to normal TrapModeProduct in that IterationPoints is kept as a trap counter and TransformedPoints and UntransformedPoints are initialised to 1 and multiplied by (1 + pz/cabs(pz)) and (1 + pzt/cabs(pzt)) respectively.

 class MMF_TrapModeSmoothProduct(MMF_TrapModeSmoothWithThreshold) {
 ;
 ; Note that this implimentation is slightly different to normal
 ; TrapModeProduct in that IterationPoints is kept as a trap counter
 ; and TransformedPoints and UntransformedPoints are initialised to
 ; 1 and multiplied by (1 + pz/cabs(pz)) and (1 + pzt/cabs(pzt))
 ; respectively.<br>
 ;
 public:
   import "common.ulb"
 
   func MMF_TrapModeSmoothProduct(Generic pparent)
     MMF_TrapModeSmoothWithThreshold.MMF_TrapModeSmoothWithThreshold(pparent)
   endfunc
   
   func Init(complex pz)
     m_Iterations = 0
     m_Solid = true
     int j = 3
      repeat
       m_UntransformedPoints[j] = m_OldUntransformedPoints[j] = (1,0)
       m_TransformedPoints[j] = m_OldTransformedPoints[j] = (1,0)
        m_IterationPoints[j] = m_OldIterationPoints[j] = 0
        m_Distances[j] = m_OldDistances[j] = 1.0
       m_Textures[j] = m_OldTextures[j] = 1.0
      until  (j=j-1)<0
      m_wastrapped = false
   endfunc
   
   func Iterate(complex pz, complex pzt, float pdistance, float ptexture)
     MMF_TrapModeSmoothWithThreshold.Iterate(pz, pzt, pdistance, ptexture)
     if (pdistance < m_Threshold)
       float id = 1.0 / m_Threshold
       m_Distances[0] = m_Distances[0] * (pdistance + @adjust) * id
       m_Textures[0] = m_Textures[0] * ptexture * id
       m_UntransformedPoints[0] = m_UntransformedPoints[0] \
                                  * (1.0 + pz / cabs(pz))
       m_TransformedPoints[0] = m_TransformedPoints[0] \
                                * (1.0 + pzt / cabs(pzt))
       m_IterationPoints[0] = m_IterationPoints[0] + 1
       m_Solid = false
       m_wastrapped = true
     endif
   endfunc
   
   func Result()
     m_Distances[0] = abs(m_Distances[0])
     ; Note that texture is not forced to positive here.
   endfunc
 
   func OldResult()
     if m_OldIterationPoints[0]>0
        m_Distances[0] = abs(m_OldDistances[0])
       m_Textures[0] = m_OldTextures[0]
       m_UntransformedPoints[0] = m_OldUntransformedPoints[0]
        m_TransformedPoints[0] = m_OldTransformedPoints[0]
       m_IterationPoints[0] = m_OldIterationPoints[0]
       m_Iterations = m_Iterations - 1
     ; Note that texture is not forced to positive here.
     endif
   endfunc
 
 default:
   title = "Smooth Product"
   heading
     text = "Note that this implimentation is slightly different to \
             normal Trap Mode Product in that the Iteration value is \
             kept as a trap counter and TransformedPoints and \
             UntransformedPoints will actually produce values when \
             using an appropriate Trap Color Mode such as Magnitude, \
             Real or Imaginary etc."
   endheading
   float param adjust
     caption = "Offset Distance"
     default = 0.0
     hint = "Modifies the distances found by this value before \
             multiplying. Try non-zero values if you get little \
             or no colouring variation, note that often increases \
             in the Trap Threshold will require increases in this \
             value and vice-versa."
   endparam
 }

Method Summary
`void`	`Init(complex pz)` call this at the beginning of each sequence
`void`	`Iterate(complex pz, complex pzt, float pdistance, float ptexture)` call this for each point
`void`	`OldResult()` call this to compute penultimate results
`void`	`Result()` call this to compute final results

Constructor Summary
`MMF_TrapModeSmoothProduct()`
`MMF_TrapModeSmoothProduct(Generic pparent)`

mmf Class MMF_TrapModeSmoothProduct

MMF_TrapModeSmoothProduct

MMF_TrapModeSmoothProduct

Init

Iterate

Result

OldResult

mmf
Class MMF_TrapModeSmoothProduct