How to use

ComplexType

in

net.imglib2.type.numeric

@Override
public void compute(final C input, final ComplexFloatType output) {
  output.set(input.getRealFloat(), input.getImaginaryFloat());
}

@Override
public O compute(I1 z1, I2 z2, O output) {
  double x = z1.getRealDouble() - z2.getRealDouble();
  double y = z1.getImaginaryDouble() - z2.getImaginaryDouble();
  output.setComplexNumber(x, y);
  return output;
}

@Override
public O compute(I z, O output) {
  output.setReal(z.getRealDouble());
  output.setImaginary(z.getImaginaryDouble());
  return output;
}

@Override
public boolean holds(T val1, U val2) {
  return (val1.getRealDouble() != val2.getRealDouble()) ||
      (val1.getImaginaryDouble() != val2.getImaginaryDouble());
}

  final int j = i * 2;
  tempIn[j] = randomAccess.get().getRealFloat();
  tempIn[j + 1] = randomAccess.get().getImaginaryFloat();
  randomAccess.fwd(dim);
tempIn[max2] = randomAccess.get().getRealFloat();
tempIn[max2 + 1] = randomAccess.get().getImaginaryFloat();
    final int j = i * 2;
    randomAccess.get().setComplexNumber(tempOut[j] / size,
      tempOut[j + 1] / size);
    randomAccess.fwd(dim);
  randomAccess.get().setComplexNumber(tempOut[max2] / size,
    tempOut[max2 + 1] / size);
    final int j = i * 2;
    randomAccess.get().setComplexNumber(tempOut[j], tempOut[j + 1]);
    randomAccess.fwd(dim);
  randomAccess.get().setComplexNumber(tempOut[max2], tempOut[max2 + 1]);

@Override
public C compute(T input1, V input2, C output) {
    output.setReal(input1.getRealDouble());
    output.setImaginary(input2.getRealDouble());
    return output;
}

@Override
public void evaluate(long[] coordinate,
  SubInterval<T> interval, ComplexType<?> output)
{
  double sum = 0;
  long numElem = 0;
  Cursor<RealType<?>> cursor = null;
  // DOES NOT COMPILE HERE
  //cursor = interval.cursor();  // probably need RegionIndexIterator idea instead
  while (cursor.hasNext()) {
    sum += cursor.get().getRealDouble();
    numElem++;
  }
  if (numElem == 0)
    output.setReal(0);
  else
    output.setReal(sum/numElem);
}

  @Override
  public C createOutput() {
    return cType.createVariable();
  }
}

@Override
public ComplexType<?> compute(RealType<?> x, ComplexType<?> output) {
  output.setComplexNumber(0, x.getRealDouble());
  return output;
}

@Override
public void compute(final T input1, final T input2, final T output) {
  T temp = input2.copy();
  temp.complexConjugate();
  temp.mul(input1);
  output.set(temp);
}

  @Override
  public void convert(final T input, final FloatType output) {
    output.setReal( input.getRealFloat() );
  }        
}

public ComplexConstantFunction(C c) {
  complex = c.copy();
}

  @Override
  public void convert( final R input, final FloatType output )
  {
    output.set( input.getImaginaryFloat() );
  }
}

@Override
public RealType<?> compute(ComplexType<?> input, RealType<?> output) {
  output.setReal(input.getRealDouble());
  return output;
}

@Override
public RealType<?> compute(ComplexType<?> input, RealType<?> output) {
  output.setReal(input.getImaginaryDouble());
  return output;
}

@Override
public void compute(INPUT input, C c) {
  c.set(complex);
}

  tempIn[ j ] = randomAccess.get().getRealFloat();
  tempIn[ j + 1 ] = randomAccess.get().getImaginaryFloat();
  randomAccess.fwd( dim );
tempIn[ max2 ] = randomAccess.get().getRealFloat();
tempIn[ max2 + 1 ] = randomAccess.get().getImaginaryFloat();
    randomAccess.get().setComplexNumber( tempOut[ j ] / size, tempOut[ j + 1 ] / size );
    randomAccess.fwd( dim );
  randomAccess.get().setComplexNumber( tempOut[ max2 ] / size, tempOut[ max2 + 1 ] / size );			
    randomAccess.get().setComplexNumber( tempOut[ j ], tempOut[ j + 1 ] );
    randomAccess.fwd( dim );
  randomAccess.get().setComplexNumber( tempOut[ max2 ], tempOut[ max2 + 1 ] );

/**
 * Gets the square of the modulus (magnitude, radius, r, etc.) of a given
 * complex number
 */
public static double getModulus2(ComplexType<?> z) {
  return
    z.getRealDouble()*z.getRealDouble() +
    z.getImaginaryDouble()*z.getImaginaryDouble();
}

@Override
public C compute(T input1, V input2, C output) {
    output.setReal(input1.getRealDouble());
    output.setImaginary(input2.getRealDouble());
    return output;
}

  @Override
  public void compute( final Composite< T > tensor, final Composite< U > evs )
  {
    evs.get( 0 ).setReal( tensor.get( 0 ).getRealDouble() );
  }
}