class Superellipsoid extends Biparam /*Sphere*/ implements java.io.Serializable
{
    static final long serialVersionUID = -251688182693574378L;
    
    Superellipsoid()
    {
		super(); // false);
		
        inPnt = new cVector();
        du = new cVector();
        dv = new cVector();
		
        name = "Superellipsoid";
        east = 2;
        north = 2;
        //uDivs = vDivs = 32;
        uDivs = 36;
        vDivs = 34;
        minUDivs = 3;
		minVDivs = 2;
		
		retile();
        recalculate();
    }

    Object3D deepCopy()
    {
        Superellipsoid s = new Superellipsoid();
        deepCopySelf(s);
        return s;
    }

    protected void deepCopyNode(Object3D other)
    {
        super.deepCopyNode(other);
        Superellipsoid s = (Superellipsoid)other;
        s.east = east;
        s.north = north;
    }

    void createEditWindow(GroupEditor callee, boolean newWindow)
    {
        //editWindow = new SuperEditor(this, deepCopy(), callee);
		if (newWindow)
			objectUI = new SuperEditor(this, deepCopy(), callee);
		else
			objectUI = new SuperEditor(this, callee);
        editWindow = objectUI.GetEditor();
    }

    double signPower(double base, double pow)
    {
		//if (base == 0)
		//	base = 0.0000001;
		
		if (base == 0 && pow == 0 || base == 1)
			return 1;
		
		if (base == 0)
			return 0;
		
		if (base == -1)
			return -1;
		
        if (base >= 0)
            return (double)Mathpow(base, pow);
        else
            return -(double)Mathpow(-base, pow);
    }

	static int tablelength = 257;
	
	static double power1 = -1;
	static double[] powtable1 = new double[tablelength];
	static double power2 = -1;
	static double[] powtable2 = new double[tablelength];
	
	double Mathpow(double base, double pow)
	{
		int basei = (int) (base * (tablelength - 1));
		
		double[] table = null;
		
		if (pow == power1)
		{
			table = powtable1;
		}
		else if (pow == power2)
		{
			table = powtable2;
		}
		else
		{
			if (power2 == -1)
			{
				power2 = pow;
				table = powtable2 = new double[tablelength];
			}
			else
			{
				power1 = pow;
				table = powtable1 = new double[tablelength];
				power2 = -1;
			}
		}
		
		if (basei != 0 && table[basei] == 0)
		{
			table[basei] = Math.pow(basei/(tablelength - 1.0), pow);
			//if (table[basei] == 0)
			//	System.out.println("POW == 0 : " + basei);
		}
		
		if (table[basei+1] == 0)
		{
			table[basei+1] = Math.pow((basei+1.0)/(tablelength - 1.0), pow);
			//if (table[basei+1] == 0)
			//	System.out.println("POW == 0");
		}
		
		double offset = base * (tablelength - 1) - basei;
		//System.out.println("offset = " + offset);
		
		return table[basei] * (1 - offset) + table[basei+1] * offset;
	}
	
    double DsignPower(double base, double pow)
    {
		if (base == 0)
			base = 0.0000000001;
		
		if (base == 1 || base == -1)
			return pow;
			
        if (base > 0)
            return pow * (double)(Mathpow(base, pow) / base); // - 1);
        else // if (base < 0)
            return pow * (double)(Mathpow(-base, pow) / -base); // - 1);
		//else
		//{
		//	if (pow == 1)
		//		return 1;
		//	else
		//		return 0;
		//}
    }

	cVector du; // = new cVector();
	cVector dv; // = new cVector();
	
    double uStretch()
    {
        return 2;
    }
    
    double vFlip(double v)
    {
        return 1-v;
    }
    
    Vertex biparamFunction(double u, double v)
    {
		//System.out.println("U = " + u + "; V = " + v);
        double uAng = LA.toRadians(u * 360);
        double vAng = LA.toRadians(v * 180 - 90);
		double mcu = Math.cos(uAng);
		double msu = Math.sin(uAng);
		double mcv = Math.cos(vAng);
		double msv = Math.sin(vAng);
		if (u == 1)
		{
			mcu = 1;
			msu = 0;
		}
		if (v == 1)
		{
			mcv = 0;
			msv = 1;
		}
		if (v == 0)
		{
			mcv = 0;
			msv = -1;
		}
        double cu = signPower(mcu, north);
        double su = signPower(msu, north);
        double cv = signPower(mcv, east);
        double sv = signPower(msv, east);
        double z = radius * cv * cu;
        double x = radius * cv * su;
        double y = radius * sv + radius;
		
        double dcu = DsignPower(mcu, north) * -msu;
        double dsu = DsignPower(msu, north) * mcu;
        double dcv = DsignPower(mcv, east) * -msv;
        double dsv = DsignPower(msv, east) * mcv;
		
		du.z = cv * dcu;
		du.x = cv * dsu;
		du.y = 0;
		dv.z = dcv * cu;
		dv.x = dcv * su;
		dv.y = dsv;
		
		//if (du.length() == 0)
		//	System.out.println("DU is null");
		//if (dv.length() == 0)
		//	System.out.println("DV is null");
		LA.vecNormalize(du);
		LA.vecNormalize(dv);
		
        Vertex temp = new Vertex();
		
        temp.norm = LA.newVector(x, y, z);
		LA.vecCross(du,dv, temp.norm);
		if (temp.norm.length() == 0)
			temp.norm.y = 2*v - 1;
		else
			LA.vecNormalize(temp.norm);

        temp./*pos.*/x = x; // = LA.newVector(x, y, z);
		temp./*pos.*/y = y;
		temp./*pos.*/z = z;
		
		//if (temp.norm.dot(temp/*.pos*/) < 0)
			//temp.norm.mul(-1);
		
        //LA.vecAdd(temp/*.pos*/, center, temp/*.pos*/);

        return temp;
    }

    boolean inside(double x, double y, double z, boolean xform)
    {
        if (xform)
            untransform(x, y, z, inPnt);
        else
            LA.setVector(inPnt, x, y, z);
        //LA.vecSub(inPnt, center, inPnt);
        LA.vecScale(inPnt, 1 / radius); // Math.abs(radius));
        for (int i=0; i < 3; i++)
            if (inPnt.get(i) < 0)
                inPnt.set(i, -inPnt.get(i));

        boolean inside = true;
        
        for (int i=0; i < 3; i++)
            if (inPnt.get(i) >= 1)
            {
                //Simplex.atom = this;
                //height = 1;
                //depth = 0;
                //return false;
                inside = false;
                break;
            }
        
        double f = 1;
        
        if (inside)
        {
            double e2 = 2 / north;
            double e1 = 2 / east;
            f = (double)(Mathpow(inPnt.x, e2) + Mathpow(inPnt.z, e2));
            f = (double)Math.pow(f, e1/e2); // east/north); // e2 / e1);
            f += (double)Mathpow(inPnt.y, e1);
            f -= 1;
        }
        //double f = (double)(signPower(inPnt.x, e2) + signPower(inPnt.z, e2));
        //f = (double)signPower(f, e2 / e1);
        //f += (double)signPower(inPnt.y, e1);
		//System.out.println("INSIDE(" + x + ", " + y + ", " + z + ") = " + f);
		
        inside = f <= 0;

        if (depth != -1 && (height <= 0 ^ inside))
        {
            Simplex.atom = this;
        }
        height = f;
        depth = 0;
        
        return radius<0?!inside:inside;
    }

    void getBounds(cVector minima, cVector maxima, boolean xform)
    {
        super.getBounds(minima, maxima, xform);
// july 2014        //for (int i=0; i < 3; i++)
//        {
//            double r = Math.abs(radius);
//            minima.x = -r;
//            minima.y = -r;
//            minima.z = -r;
//            //maxima[i] = center[i] + radius;
//            maxima.x = r;
//            maxima.y = r;
//            maxima.z = r;
//        }
//
//        if (xform)
//            transformBounds(minima, maxima);
    }

    void generatePOV(StringBuffer buffer)
    {
        generateNameComment(buffer);
        generateIndent(buffer);
        buffer.append("superellipsoid { < ");
        buffer.append(north);
        buffer.append(",");
        buffer.append(east);
        buffer.append(">\n");
        generateIndent(buffer);
        buffer.append("    scale ");
        buffer.append(radius);
        buffer.append("\n");
        //generateIndent(buffer);
        //buffer.append("    translate ");
        //LA.toPOVRay(center, buffer);
        //buffer.append("\n");
        generateTransform(buffer);
        generateIndent(buffer);
        buffer.append("}\n");
    }

    double east;
    double north;
	double radius = 0.5;
    private cVector inPnt;
}