/* This file is part of the source code for 3D-XplorMath-J, Version 1.0 (January 2008).
* Copyright (c) 2008 The 3D-XplorMath Consortium (http://3d-xplormath.org).
* This source code is released under a BSD License, which allows redistribution
* in source and binary form, with or without modification, provided copyright
* and license information are included, and with no warranty or guarantee of
* any kind. For details, see http://3d-xplormath.org/j/source/BSDLicense.txt
*/
package vmm3d.surface.parametric;
import java.awt.Color;
import vmm3d.core.Complex;
import vmm3d.core.I18n;
import vmm3d.core.IntegerParam;
import vmm3d.core.Parameter;
import vmm3d.core.RealParamAnimateable;
import vmm3d.core.View;
import vmm3d.core3D.ComplexVector3D;
import vmm3d.core3D.GridTransformMatrix;
import vmm3d.core3D.Vector3D;
import vmm3d.core3D.View3DLit;
import vmm3d.surface.SurfaceView;
public class SchoenCLPsurface extends WeierstrassMinimalSurface {
private RealParamAnimateable aa = new RealParamAnimateable("vmm3d.surface.parametric.SchoenCLPsurface.aa",0.6,0.52,0.98);
private RealParamAnimateable bb = new RealParamAnimateable("vmm3d.surface.parametric.SchoenCLPsurface.bb",0.2,0.48,0.02);
//ComplexVector3D[][] integrationGrid;
//boolean needsIntegrationGrid = true;
public SchoenCLPsurface() {
super();
addParameter(bb);
bb.setMaximumValueForInput(0.95); // if one wants to morph that far, increase resolution
bb.setMinimumValueForInput(0.02);
addParameter(aa);
aa.setMaximumValueForInput(0.99); // if one wants to morph that far, increase resolution
aa.setMinimumValueForInput(0.05);
setDefaultViewUp(new Vector3D(-0.57, 0.6, 0.58));
setDefaultViewpoint(new Vector3D(15, -25, 40));
setDefaultWindow(-5,5,-4,4);
uPatchCount.setValueAndDefault(12);
vPatchCount.setValueAndDefault(24);
umin.reset(0.005);
umax.reset(0.999);
vmin.reset(-1.0);
vmax.reset(1.0);
removeParameter(vmin);
removeParameter(vmax);
removeParameter(umin);
removeParameter(umax);
//afp.setValue(Math.PI/2);
iFirstInHelper = false;
// change the next two booleans for testing (or later for education)
wantsToSeeDomain = false;
wantsToSeeGaussImage = false;
if (wantsToSeeGaussImage) wantsToSeeDomain = true;//
if (wantsToSeeDomain) {setDefaultViewUp(new Vector3D(0,0,1));
setDefaultViewpoint(new Vector3D(0,0,40));}
multipleCopyOptions = new int[] {2};
canShowConjugateSurface = true;
}
public View getDefaultView() {
//SurfaceView view = (SurfaceView)super.getDefaultView(); // its actually a WMSView
WMSView view = new WMSView();
view.setGridSpacing(12);
setDefaultOrientation(View3DLit.REVERSE_ORIENTATION); // where should this go?
float c0 = (float)0.2;
//view.getLightSettings().setLight0(new Color(c0,c0,c0));
view.getLightSettings().setAmbientLight(new Color(c0,c0,c0));
//view.getLightSettings().getDirectionalLight2().setItsColor(new Color((float)0.5,(float)1.0,(float)0.0));
//view.getLightSettings().getDirectionalLight2().setItsDirection (new Vector3D(0.66,-0.34,-0.66));
view.getLightSettings ().setSpecularExponent(100);
view.getLightSettings().setSpecularRatio( (float)0.8 );
return view;
}
private int um,vm;
private double alpha,beta, c2a, c2b, coeff,coecc,scale;
private Complex ccff;
private Vector3D surf_1,surf_2 ;
protected void createData() {
super.createData(); // helperArray created, flag0 & flag05 are set
computePeriodData();
data.discardGridTransforms();
GridTransformMatrix[] trList = new GridTransformMatrix[64];
trList[0] = new GridTransformMatrix();
GridTransformMatrix a = new GridTransformMatrix();
trList[1] = new GridTransformMatrix().scale(-1,-1,1);
if (!wantsToSeeDomain) {
data.addGridTransform(trList[1]);
for (int e=0; e < 2; e++){
trList[2+e] = new GridTransformMatrix(trList[e]).scale(-1,-1,-1).reverse().translate(surf_1);
data.addGridTransform(trList[2+e]);
}
if (!inAssociateMorph) {
if (flag0||flag05){
a = new GridTransformMatrix().scale(-1,-1,1).reverse().translate(surf_1.x,surf_1.y,0);
for (int e=0; e < 4; e++){
trList[4+e] = new GridTransformMatrix(trList[e]).leftMultiplyBy(a);
data.addGridTransform(trList[4+e]);
}
a = new GridTransformMatrix().scale(-1,-1,1);
for (int e=0; e < 4; e++){
trList[8+e] = new GridTransformMatrix(trList[2+e]).leftMultiplyBy(a);
data.addGridTransform(trList[8+e]);
}
if (getNumberOfPieces()==2){
if (flag0)
a = new GridTransformMatrix().scale(1,1,-1).translate(0,0,surf_2.z);
else if (flag05)
a = new GridTransformMatrix().scale(1,1,-1).translate(surf_2.x,surf_2.y,surf_2.z);
for (int e=0; e < 12; e++){
trList[12+e] = new GridTransformMatrix(trList[e]).leftMultiplyBy(a);
//trList[15+e] = new GridTransformMatrix(trList[1+(3+e)*e]).leftMultiplyBy(a);
data.addGridTransform(trList[12+e]);
//data.addGridTransform(trList[15+e]);
}
} //if (getNumberOfPieces()==2)
}
} // if (!inAssociateMorph)
} // (!wantsToSeeDomain)
}
public static double paramRescaleEnd(double x){
double y;
y = Math.sin(Math.PI/2*x);
return y;
}
public static double paramRescaleStart(double x){
double y;
y = 1 - Math.cos(Math.PI/2*x);
return y;
}
public static double paramRescaleBoth(double x){
double y;
y = (1.0 - Math.cos(Math.PI*x))/2.0;
return y;
}
public static double paramRescaleMiddle(double x){
double y;
y = (1.0 + x*Math.abs(x))/2.0;
return y;
}
// override the default Cartesian Grid
protected Complex domainGrid(double u, double v){
boolean vflag = false;
double ph = 0;
Complex z;
// This is the domainGrid if one wants the Gauss map as coordinate function
double r = paramRescaleEnd(u);
if (v < 0 ) {v = -v; vflag = true;}
if (v <= 1.0/3.0)
ph = beta*paramRescaleEnd(3*v);
else if (v <= 2.0/3.0)
ph = beta - (beta-alpha)*paramRescaleBoth(3*v-1);
else if (v <= 1)
ph = alpha + (Math.PI*0.5 - alpha)*paramRescaleStart(3*v-2);
z = new Complex(r*Math.cos(ph), r*Math.sin(ph));
if (wantsToSeeGaussImage) z = mu(z);
if (vflag) z = z.conj();
return z.conj();
/* // This is the Grid for using the hexagon function, needs to take sqrt of a slit
double r = paramRescaleEnd(u);
ph = Math.PI*paramRescaleBoth(v);
z = new Complex(r*Math.cos(ph), r*Math.sin(ph));
if (wantsToSeeGaussImage) z = gauss(z);
return z; */
}
/**
* The following two functions are the Weierstrass data that
* define this surface. It is best shown on the above domainGrid.
*/
protected Complex gauss(Complex z) {
return z;
}
protected Complex mu(Complex z) {
boolean vflag = false;
if (z.im < 0) {z = z.conj(); vflag = true;}
Complex g2 = z.times(z);
Complex w2 = g2.inverse();
w2.assignPlus(g2);
Complex v2 = w2.minus(2*c2a);
w2.re = w2.re - 2*c2b;
w2.assignTimes(v2);
v2 = w2.squareRootNearer(I_C);
if (vflag) v2 = v2.conj();
return v2;
}
protected Complex hPrime(Complex z) {
Complex w = mu(z);
w.assignTimes(z);
w.assignInvert();
return w;
}
protected void redoConstants(){
// global variables independent of the points, hence thread safe
super.redoConstants();
alpha= 0.5*Math.PI*aa.getValue();
beta = 0.5*Math.PI*bb.getValue();
c2a = Math.cos(2*alpha);
c2b = Math.cos(2*beta);
coeff= 0.5*(c2a - c2b); ccff = new Complex(0, -2.0*coeff);
coecc= (c2a + c2b);
scale= 1;
}
/**
* We want to center the surface (one hexagon) already at the helper Level.
*/
protected ComplexVector3D getCenter(){
ComplexVector3D gC = new ComplexVector3D(helperArray[0][0]);
gC = (gC.plus(helperArray[0][vcount-1])).times(0.5);
return gC; // new ComplexVector3D(ZERO_C,ZERO_C,ZERO_C);
}
public void computePeriodData(){
surf_1 = surfacePoint(umax.getValue(), 1.0/3.0).times(2.0);
surf_2 = surfacePoint(umax.getValue(), 2.0/3.0).times(2.0);
//System.out.println(surf_1.z);
}
/**
* Override to close the hole around the images of P, -1/P.
*/
/* public Vector3D surfacePoint(double u, double v) {
}
*/
}
Ads help maintain this website.