コード例 #1
0
ファイル: StatFunctions.java プロジェクト: Balkanlii/nlp
 public static double pt(double t, double df) {
   // ALGORITHM AS 3  APPL. STATIST. (1968) VOL.17, P.189
   // Computes P(T<t)
   double a, b, idf, im2, ioe, s, c, ks, fk, k;
   double g1 = 0.3183098862; // =1/pi;
   if (df < 1) throw new IllegalArgumentException("Illegal argument df for pt(t,df).");
   idf = df;
   a = t / Math.sqrt(idf);
   b = idf / (idf + t * t);
   im2 = df - 2;
   ioe = idf % 2;
   s = 1;
   c = 1;
   idf = 1;
   ks = 2 + ioe;
   fk = ks;
   if (im2 >= 2) {
     for (k = ks; k <= im2; k += 2) {
       c = c * b * (fk - 1) / fk;
       s += c;
       if (s != idf) {
         idf = s;
         fk += 2;
       }
     }
   }
   if (ioe != 1) return 0.5 + 0.5 * a * Math.sqrt(b) * s;
   if (df == 1) s = 0;
   return 0.5 + (a * b * s + Math.atan(a)) * g1;
 }
コード例 #2
0
  /* CALCULATE VALUES QUADRANTS: Calculate x-y values where direction is not
  parallel to eith x or y axis. */
  public static void calcValuesQuad(int x1, int y1, int x2, int y2) {
    double arrowAng = Math.toDegrees(Math.atan((double) haw / (double) al));
    double dist = Math.sqrt(al * al + aw);
    double lineAng =
        Math.toDegrees(Math.atan(((double) Math.abs(x1 - x2)) / ((double) Math.abs(y1 - y2))));

    // Adjust line angle for quadrant
    if (x1 > x2) {
      // South East
      if (y1 > y2) lineAng = 180.0 - lineAng;
    } else {
      // South West
      if (y1 > y2) lineAng = 180.0 + lineAng;
      // North West
      else lineAng = 360.0 - lineAng;
    }

    // Calculate coords
    xValues[0] = x2;
    yValues[0] = y2;
    calcCoords(1, x2, y2, dist, lineAng - arrowAng);
    calcCoords(2, x2, y2, dist, lineAng + arrowAng);
  }
コード例 #3
0
 public static void drawLine(Graphics g, int x1, int y1, int x2, int y2, int lineWidth) {
   if (lineWidth == 1) g.drawLine(x1, y1, x2, y2);
   else {
     double angle;
     double halfWidth = ((double) lineWidth) / 2.0;
     double deltaX = (double) (x2 - x1);
     double deltaY = (double) (y2 - y1);
     if (x1 == x2) angle = Math.PI;
     else angle = Math.atan(deltaY / deltaX) + Math.PI / 2;
     int xOffset = (int) (halfWidth * Math.cos(angle));
     int yOffset = (int) (halfWidth * Math.sin(angle));
     int[] xCorners = {x1 - xOffset, x2 - xOffset + 1, x2 + xOffset + 1, x1 + xOffset};
     int[] yCorners = {y1 - yOffset, y2 - yOffset, y2 + yOffset + 1, y1 + yOffset + 1};
     g.fillPolygon(xCorners, yCorners, 4);
   }
 }
コード例 #4
0
ファイル: Car.java プロジェクト: embix/Tectonicus
  /**
   * Places the car. The car has to follow the ground. This is done by casting 4 rays (one from each
   * wheel) to the ground and calculating the resulting rotation angles to let the car follow the
   * ground as close as possible.
   *
   * @param ground the ground
   * @return if it was possible to place the car or not
   */
  public boolean place(Object3D ground) {
    SimpleVector dropDown = new SimpleVector(0, 1, 0);

    /**
     * To cast the rays, the car will be rotated in horizontal position first, rotated around the
     * y-axis according to the cars direction and moved 10 units up.
     */
    Matrix rotMat = getRotationMatrix();
    rotMat.setIdentity();
    setRotationMatrix(rotMat);

    rotateY(yRot);
    translate(0, -10, 0);

    /** Cast the rays... */
    float rightFrontHeight =
        ground.calcMinDistance(rightFront.getTransformedCenter(), dropDown, 4 * 30);
    float rightRearHeight =
        ground.calcMinDistance(rightRear.getTransformedCenter(), dropDown, 4 * 30);
    float leftFrontHeight =
        ground.calcMinDistance(leftFront.getTransformedCenter(), dropDown, 4 * 30);
    float leftRearHeight =
        ground.calcMinDistance(leftRear.getTransformedCenter(), dropDown, 4 * 30);

    /** Correct the movement we did above. */
    translate(0, 10, 0);

    /** Reset the rotation matrix again. */
    rotMat = getRotationMatrix();
    rotMat.setIdentity();
    setRotationMatrix(rotMat);

    /** The rays all hit the ground, the car can be placed */
    if (rightFrontHeight != Object3D.COLLISION_NONE
        && rightRearHeight != Object3D.COLLISION_NONE
        && leftFrontHeight != Object3D.COLLISION_NONE
        && leftRearHeight != Object3D.COLLISION_NONE) {

      /** Correct the values (see translation above) */
      rightFrontHeight -= 10;
      rightRearHeight -= 10;
      leftFrontHeight -= 10;
      leftRearHeight -= 10;

      /**
       * Calculate the angles between the wheels and the ground. This is done four times: for the
       * front and the rear as well as for left and right. Front/rear and left/right are averaged
       * afterwards.
       */
      double angleFront = rightFrontHeight - leftFrontHeight;
      double as = (angleFront / (16d));
      angleFront = Math.atan(as);

      double angleRear = rightRearHeight - leftRearHeight;
      as = (angleRear / (16d));
      angleRear = Math.atan(as);

      float rot = (float) ((angleFront + angleRear) / 2d);
      rotateZ(rot);

      double angleLeft = leftFrontHeight - leftRearHeight;
      as = (angleLeft / (16d));
      angleLeft = Math.atan(as);

      double angleRight = rightFrontHeight - rightRearHeight;
      as = (angleRight / (16d));
      angleRight = Math.atan(as);

      rot = (float) ((angleLeft + angleRight) / 2d);

      rotateX(rot);

      /**
       * The car is correctly rotated now. But we still have to adjust the height. We are simply
       * taking the minimum distance from all wheels to the ground as the new height.
       */
      float down = rightFrontHeight;
      if (leftFrontHeight < down) {
        down = leftFrontHeight;
      }
      if (rightRearHeight < down) {
        down = rightRearHeight;
      }
      if (leftRearHeight < down) {
        down = leftRearHeight;
      }

      dropDown.scalarMul(down - 4);
      translate(dropDown);

    } else {
      return false;
    }

    /** And finally, rotate the car around Y (that's the car's direction) */
    rotateY(yRot);
    return true;
  }
コード例 #5
0
ファイル: Arrow.java プロジェクト: springer126/jDevelop
  private int[] Translated_Point(double constant, int[] arrow_x, int[] arrow_y, double gradient) {
    double[] translated = new double[2];
    double[][] trans_matrix = new double[2][2];
    double ang_rot;
    double[] point2_temp = new double[4];
    int cnt, row, col;
    int[] pt = new int[2];

    translated[0] = 0.00;
    translated[1] = 0.00;
    trans_matrix[0][0] = 0.00;
    trans_matrix[0][1] = 0.00;
    trans_matrix[1][0] = 0.00;
    trans_matrix[1][1] = 0.00;
    point2_temp[0] = 0.00;
    point2_temp[1] = 0.00;
    point2_temp[2] = 0.00;
    point2_temp[3] = 0.00;
    cnt = 0;
    row = 0;
    col = 0;
    ang_rot = 0.00;

    // translate the line to the origin
    // thus the translated points to be found are:
    translated[0] = arrow_x[1];
    if (constant < 0) {
      translated[1] = arrow_y[1] + Math.abs(constant);
    } else {
      translated[1] = arrow_y[1] - Math.abs(constant);
    }

    // find the angle of rotation
    ang_rot = Math.atan(gradient);

    if ((end_x - start_x) == 0) {
      if (arrow_x[0] > 0) {
        translated[0] = arrow_x[1] - arrow_x[0];
      } else {
        translated[0] = arrow_x[1] + arrow_x[0];
      }
      translated[1] = arrow_y[1];
      trans_matrix[0][0] = -1;
      trans_matrix[0][1] = 0;
      trans_matrix[1][0] = 0;
      trans_matrix[1][1] = 1;
    } else {
      // declare the transformation matrix
      trans_matrix[0][0] = Math.cos(2 * ang_rot);
      trans_matrix[0][1] = Math.sin(2 * ang_rot);
      trans_matrix[1][0] = Math.sin(2 * ang_rot);
      trans_matrix[1][1] = Math.cos(2 * ang_rot) * (-1);
    }

    // multiply the transformation matrix with the point
    // store it in an array
    for (row = 0; row < 2; row++) {
      for (col = 0; col < 2; col++) {
        point2_temp[cnt] = trans_matrix[row][col] * translated[col];
        cnt++;
      }
    }

    if ((end_x - start_x) == 0) {
      if (arrow_x[0] > 0) {
        arrow_x[2] = (int) Math.round(point2_temp[0] + point2_temp[1] + arrow_x[0]);
      } else {
        arrow_x[2] = (int) Math.round(point2_temp[2] + point2_temp[1] - arrow_x[0]);
      }
      arrow_y[2] = (int) Math.round(point2_temp[2] + point2_temp[3]);
    } else {
      // from the array, get the reflected point
      arrow_x[2] = (int) Math.round(point2_temp[0] + point2_temp[1]);
      if (constant < 0) {
        arrow_y[2] = (int) Math.round(point2_temp[2] + point2_temp[3] - Math.abs(constant));
      } else {
        arrow_y[2] = (int) Math.round(point2_temp[2] + point2_temp[3] + Math.abs(constant));
      }
    }
    pt[0] = arrow_x[2];
    pt[1] = arrow_y[2];
    return pt;
  }
コード例 #6
0
  private int decodeChunk(int prof) {

    int offset = 6;
    int id = getUShort();
    int longueur = getInt();
    if (longueur < 0) return 0;

    this.pushChunk(id);

    /*
    	for(int x=0;x<prof;x++)
    		System.out.print(" ");
    	Log.log(prof + " - ID=" + Integer.toHexString(id) + " LONGUEUR=" + longueur );

    */
    switch (id) {
      case FILE_VERSION:
        {
          long ver = getUInt();
          this.fileVersion = (int) ver;
          // System.out.println("FILE VERSION="+this.fileVersion);
          offset += 4;
        }
        break;

      case KEYFRAME_VERSION:
        {
          long ver = getUInt();
          this.keyFrameVersion = (int) ver;
          offset += 4;
          // System.out.println("KEYFRAME VERSION="+this.keyFrameVersion);
        }
        break;

      case MESH_VERSION:
        {
          long ver = getUInt();
          this.meshVersion = (int) ver;
          offset += 4;
          // System.out.println("MESH VERSION="+this.meshVersion);

        }
        break;
        /*
        case 0x0100:
        {
        	double scl=(double) getFloat();
        	offset+=4;
        	System.out.println("MASTER SCALE="+scl);
        }
        break;
        */

      case UNIT: // MASTER_SCALE 1.0 <=> 1==1inch
        this.unit = getFloat();
        offset += 4;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case BGCOLOR:
        do {
          int colorBId = getUShort();
          int lBColor = getInt();
          offset += 6;
          switch (colorBId) {
            case RGBF:
            case RGBFG:
              this.backgroundColor = readFloatColor();
              offset += 12;
              break;
            case RGBB:
            case RGBBG:
              this.backgroundColor = readByteColor();
              offset += 3;
              break;
          }
        } while (offset < longueur);
        break;

      case OBJECT:
        lastObjectName = getString();
        offset += lastObjectName.length() + 1;

        while (offset < longueur) offset += decodeChunk(prof + 1);

        // TODO: 3DS LOADING MAY BE IT IS NOT NEEDED
        if (cObjet instanceof Mesh3D) {

          //	((Mesh3D)cObjet).buildVertexId();
          //	((Mesh3D)cObjet).buildFaceId();
          //	((Mesh3D)cObjet).removeDuplicateVertices();

          //	((Mesh3D)cObjet).buildFacesNormals();
          //	((Mesh3D)cObjet).buildSphereBoxAndCenter();
          // Auto octree
          //	((Mesh3D)cObjet).buildMesh3DOctree();
        }

        //	if(cObjet!=null)
        // cObjet.build();
        break;

      case OBJECT_HIDDEN:
        ((Mesh3D) cObjet).setVisible(false);
        break;

      case OBJECT_DONT_CAST_SHADOW:
        if (cObjet instanceof Mesh3D) ((Mesh3D) cObjet).setCastShadow(false);
        break;
      case OBJECT_DONT_RECV_SHADOW:
        if (cObjet instanceof Mesh3D) ((Mesh3D) cObjet).setRecvShadow(false);
        break;

      case CAMERA_ATMOS_RANGE:
        float nearAtmosRange = getFloat();
        float farAtmosRange = getFloat();
        offset += 8;
        break;

      case CAMERA:
        {
          cObjet = new Camera3D();
          cObjet.id = -1;
          cObjet.nom = lastObjectName;
          cAxe = new Axis3D();
          cObjet.axes = cAxe;
          tObjets3D[nbObjet] = cObjet;
          nbObjet++;

          float x = getFloat();
          float y = getFloat();
          float z = getFloat();
          float tx = getFloat();
          float ty = getFloat();
          float tz = getFloat();
          float rz = getFloat();
          float focus = getFloat();
          // System.out.println("focal lenght="+focus);
          double FOV = 180.0 * 2.0 * Math.atan(44.1828 / (focus * 2)) / Math.PI;
          // System.out.println("FOV CALC="+FOV);

          cObjet.position.set(x, z, y);
          // cObjet.axes.add(x,z,y);
          // Log.log(cObjet.position.toString());

          cObjet.axes.origine.set(x, z, y);
          cObjet.axes.axeZ.set(tx - x, tz - z, ty - y);
          cObjet.axes.axeX.set(ty - y, 0, -(tx - x));

          cObjet.axes.axeY.copy(cObjet.axes.axeZ).cross(cObjet.axes.axeX);

          cObjet.axes.axeX.normalize();
          cObjet.axes.axeY.normalize();
          cObjet.axes.axeZ.normalize();

          cObjet.rotation.z = rz;
          cObjet.pivot.set(0, 0, 0);

          if (this.meshVersion == 0) focus = (float) ((Camera3D) cObjet).width;
          ((Camera3D) cObjet).focus = focus; // rotation.rz=rz;
          offset += 32;

          // tObjets3D[nbObjet]=new Scene3DObject();
          // nbObjet++;

          while (offset < longueur) offset += decodeChunk(prof + 1);
        }
        break;

      case LIGHT:
        {
          float x = getFloat();
          float y = getFloat();
          float z = getFloat();
          offset += 12;

          while (offset < longueur) offset += decodeChunk(prof + 1);
        }
        break;

      case TRIMESH:
        cObjet = new Mesh3D();
        cObjet.nom = lastObjectName;
        cObjet.id = -1;
        tObjets3D[nbObjet] = cObjet;
        nbObjet++;
        cAxe = new Axis3D();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        cObjet.axes = cAxe;
        break;

      case VERTEXL:
        int nbV = getUShort();
        offset += 2;
        cPoints3D = new Vertex3D[nbV];
        mappingU = new float[nbV];
        mappingV = new float[nbV];

        for (int nV = 0; nV < nbV; nV++) {
          float x = getFloat();
          float y = getFloat();
          float z = getFloat();
          cPoints3D[nV] = new Vertex3D(x, z, y);
          offset += 12;
        }
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case FACEL:
        int nbP = getUShort();
        offset += 2;
        cPolygones3D = new Face3D[nbP];
        for (int nP = 0; nP < nbP; nP++) {
          int p1 = getUShort();
          int p2 = getUShort();
          int p3 = getUShort();
          int info = getUShort();
          Vertex3D p3D[] = new Vertex3D[3];
          p3D[0] = cPoints3D[p3];
          p3D[1] = cPoints3D[p2];
          p3D[2] = cPoints3D[p1];
          cPolygones3D[nP] = new Face3D(p3D[0], p3D[1], p3D[2]);
          cPolygones3D[nP].u0 = mappingU[p3];
          cPolygones3D[nP].v0 = mappingV[p3];
          cPolygones3D[nP].u1 = mappingU[p2];
          cPolygones3D[nP].v1 = mappingV[p2];
          cPolygones3D[nP].u2 = mappingU[p1];
          cPolygones3D[nP].v2 = mappingV[p1];
          offset += 8;
        }

        ((Mesh3D) cObjet).vertices3D = cPoints3D;
        ((Mesh3D) cObjet).faces3D = cPolygones3D;

        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case SMOOTHL:
        int nbpoly = cPolygones3D.length;
        for (int nP = 0; nP < nbpoly; nP++) {
          int nbSmooth = getInt();
          cPolygones3D[nP].smoothGroupMask = nbSmooth;
          offset += 4;
        }
        break;

      case FACEM:
        String nom = getString();
        offset += nom.length() + 1;
        cMateriau = getTempMateriauByName(nom);
        int nbF = getUShort();
        offset += 2;
        for (int nF = 0; nF < nbF; nF++) {
          int numF = getUShort();
          cPolygones3D[numF].material = cMateriau;
          offset += 2;
        }
        while (offset < longueur) offset += decodeChunk(prof + 1);

        break;

      case MAPPINGVL:
        int nbMV = getUShort();
        offset += 2;
        for (int nV = 0; nV < nbMV; nV++) {
          float u = getFloat();
          float v = getFloat();
          mappingU[nV] = u;
          mappingV[nV] = -v;
          offset += 8;
        }
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case OBJAXES:
        double x = getFloat();
        double y = getFloat();
        double z = getFloat();
        cAxe.axeX.set(x, z, y);

        x = getFloat();
        y = getFloat();
        z = getFloat();
        cAxe.axeZ.set(x, z, y);

        x = getFloat();
        y = getFloat();
        z = getFloat();
        cAxe.axeY.set(x, z, y);

        x = getFloat();
        y = getFloat();
        z = getFloat();
        cAxe.origine.set(x, z, y);

        offset += 48;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIAL:
        cMateriau = new Material();
        tMateriaux3D[nbMaterial] = cMateriau;
        nbMaterial++;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALNAME:
        cMateriau.nom = getString();
        offset += cMateriau.nom.length() + 1;
        while (offset < longueur) offset += decodeChunk(prof + 1);

        break;

      case MATERIALAMBIENTCOLOR:
        do {
          int colorAId = getUShort();
          int lAColor = getInt();
          offset += 6;
          switch (colorAId) {
            case RGBF:
            case RGBFG:
              cMateriau.ambientColor = readFloatColor();
              offset += 12;
              break;
            case RGBB:
            case RGBBG:
              cMateriau.ambientColor = readByteColor();
              offset += 3;
              break;
          }
        } while (offset < longueur);
        break;

      case MATERIALDIFFUSECOLOR:
        do {
          int colorDId = getUShort();
          int lDColor = getInt();
          offset += 6;
          switch (colorDId) {
            case RGBF:
            case RGBFG:
              cMateriau.diffuseColor = readFloatColor();
              offset += 12;
              break;
            case RGBB:
            case RGBBG:
              cMateriau.diffuseColor = readByteColor();
              offset += 3;
              break;
          }
        } while (offset < longueur);
        break;

      case MATERIALSPECULARCOLOR:
        do {

          int colorSId = getUShort();
          int lSColor = getInt();
          offset += 6;
          switch (colorSId) {
            case RGBF:
            case RGBFG:
              cMateriau.specularColor = readFloatColor();
              offset += 12;
              break;
            case RGBB:
            case RGBBG:
              cMateriau.specularColor = readByteColor();
              offset += 3;
              break;
          }
        } while (offset < longueur);
        break;

      case MATERIALSHINEPERCENT:
        int shineId = getUShort();
        int lShine = getInt();
        offset += 6;
        switch (shineId) {
          case PERCENTF:
            cMateriau.specularPower = readFloatPercent();
            offset += 4;
            break;
          case PERCENTI:
            cMateriau.specularPower = readIntPercent();
            offset += 2;
            break;
        }
        break;

      case MATERIALILLUMPERCENT:
        int illumId = getUShort();
        int lIllum = getInt();
        offset += 6;
        switch (illumId) {
          case PERCENTF:
            cMateriau.selfIlluminationLevel = readFloatPercent();
            offset += 4;
            break;
          case PERCENTI:
            cMateriau.selfIlluminationLevel = readIntPercent();
            offset += 2;
            break;
        }
        // Log.log(cMateriau.nom+" emi="+emi);
        break;

      case MATERIALSHINEFPERCENT:
        int shineFId = getUShort();
        int lShineF = getInt();
        offset += 6;
        switch (shineFId) {
          case PERCENTF:
            cMateriau.specularLevel = readFloatPercent() * 255 / 100;
            offset += 4;
            break;
          case PERCENTI:
            cMateriau.specularLevel = (readIntPercent() * 255) / 100;
            offset += 2;
            break;
        }
        break;

      case MATERIALTRANSPERCENT:
        int transId = getUShort();
        int lTrans = getInt();
        offset += 6;
        switch (transId) {
          case PERCENTF:
            cMateriau.alphaLevel = readFloatPercent() * 255 / 100;
            offset += 4;
            break;
          case PERCENTI:
            cMateriau.alphaLevel = (readIntPercent() * 255) / 100;
            offset += 2;
            break;
        }
        break;

      case MATERIALTRANSFPERCENT:
        int transFId = getUShort();
        int lTransF = getInt();
        offset += 6;
        switch (transFId) {
          case PERCENTF:
            cMateriau.alphaFalloff = readFloatPercent() * 255 / 100;
            offset += 4;
            break;
          case PERCENTI:
            cMateriau.alphaFalloff = (readIntPercent() * 255) / 100;
            offset += 2;
            break;
        }
        break;

      case MATERIALTEXTUREDIFF:
        cMapping = new MappingUV();
        cMateriau.mapping = cMapping;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTUREBUMP:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTUREENV:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTUREOPAC:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTURESPEC:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTURESHIN:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MATERIALTEXTUREILLUM:
        cMapping = new MappingUV();
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MAPPINGFILE:
        String fileName = getString();
        // System.out.println("MAPPINGFILE="+fileName);
        offset += fileName.length() + 1;

        String textureCacheKey = this.ressourcePath + fileName;
        URLTexture nTexture = (URLTexture) textureCache.get(textureCacheKey);
        if (nTexture == null) {
          nTexture = new URLTexture();
          nTexture.nom = fileName;
          nTexture.sourceFile = fileName;
          nTexture.baseURL = this.ressourcePath;
          textureCache.put(textureCacheKey, nTexture);
          this.textures[this.nbTexture++] = nTexture;
        }

        // There cache will cause trouble if same texture used for different kind of map
        if (this.getLastParentChunk() == MATERIALTEXTUREDIFF) {
          nTexture.type = DzzD.TT_RGB;
          cMateriau.diffuseTexture = nTexture;
        }
        if (this.getLastParentChunk() == MATERIALTEXTUREBUMP) {
          nTexture.type = DzzD.TT_HNORMAL;
          cMateriau.bumpNormalTexture = nTexture;
        }
        if (this.getLastParentChunk() == MATERIALTEXTUREENV) {
          nTexture.type = DzzD.TT_ENV;
          cMateriau.envTexture = nTexture;
        }
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MAPPINGOFFSETU:
        float offseMappingU = getFloat();
        offset += 4;
        cMapping.ofsU = offseMappingU;
        break;

      case MAPPINGOFFSETV:
        float offseMappingV = getFloat();
        offset += 4;
        cMapping.ofsV = offseMappingV;
        break;

        /*
         * KEYFRAME BEGIN
         */
      case KEYFHIER:
        // System.out.println("KEYFHIER");
        lastObjectName = getString(); // Name in mesh section
        // System.out.println("Mesh section name="+lastObjectName);
        offset += lastObjectName.length() + 1;

        int info1 = getUShort();
        int info2 = getUShort();
        int idObjetParent = getShort();

        // System.out.println("------- info1: "+info1);
        // System.out.println("------- info2: "+info2);
        // System.out.println("------- idObjetParent parent:("+idObjetParent+")");

        offset += 6;

        if ((this.meshVersion >= 3)
            && ((info1 & 0x4000) == 0)
            && (!lastObjectName.equals("$$$DUMMY"))) {
          // Log.log("------------ Instance From Object" + lastObjectName);
          cObjet = (Scene3DObject) getTempObjetByName(lastObjectName).getClone(false);
          cObjet.nom = "Instance" + nbObjet; // lastObjectName;
          cObjet.id = this.cObjetId;
          tObjets3D[nbObjet] = cObjet;
          nbObjet++;
        } else {
          if (lastObjectName.equals("$$$DUMMY")) {
            // System.out.println("New object");
            cObjet = new Mesh3D();
            cObjet.nom = "$$$DUMMY";
            cObjet.id = this.cObjetId;
            tObjets3D[nbObjet] = cObjet;
            nbObjet++;
          } else {

            this.cObjet = getTempObjetByName(lastObjectName);
            if (this.cObjet instanceof Camera3D) {
              if (getLastParentChunk() == KEYFCAMTARGETFRAME) {
                // System.out.println("TARGET FOR "+lastObjectName);
                // this.cObjet.setTarget(DzzD.newPoint3D());
              }
            }
          }
        }

        // System.out.println("ID objet==" + cObjetId);

        this.cObjet.id = this.cObjetId;
        if (idObjetParent != 65535) {

          Scene3DObject parent = getTempObjetById(idObjetParent);
          if (parent != null) this.cObjet.parent = parent;
          // System.out.println(cObjet.getName()+" is child of "+cObjet.getParent().getName());
        }
        /*
        if(this.cObjet.parent!=null && !lastObjectName.equals("$$$DUMMY"))
        	System.out.println("-" + lastObjectName+"("+ this.cObjet.id +"):parent:("+idObjetParent+")"+this.cObjet.parent.nom);
        */
        while (offset < longueur) offset += decodeChunk(prof + 1);

        break;

      case KEYFNAME: // - Instance objects name.
        String instanceName = getString();
        // Log.log("instanceName="+instanceName);
        cObjet.nom = instanceName;
        offset += instanceName.length() + 1;
        break;

      case KEYFID:
        int idObjet = getUShort();

        offset += 2;
        this.cObjetId = idObjet;
        // System.out.println("ID OBJ="+cObjetId);
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFTRANS:

        // Read Track Header
        int info = getShort();
        offset += 2;
        for (int niu = 0; niu < 8; niu++) {
          // Read Unknow TrackHeader info 8 byte
          byte infoUnknow = (byte) getByte();
          offset += 1;
        }

        // Read number ok keys
        int nbKey = (int) getUInt();
        offset += 4;

        Point3D cPosition = new Point3D();
        Point3D lastPosition = new Point3D();
        if (this.animators[cObjetId] == null)
          this.animators[cObjetId] = new Scene3DObjectAnimator();

        // Read all track
        for (int xKey = 0; xKey < nbKey; xKey++) {
          // Read the frame number for this key
          int nKey = (int) getUInt();
          offset += 4;

          // Read Spline flag
          int splinef = getShort();
          offset += 2;

          // Read Spline info depending on spline flag
          if ((splinef & 1) != 0) {
            // Read tension
            getFloat();
            offset += 4;
          }
          if ((splinef & 2) != 0) {
            // Read continuity
            getFloat();
            offset += 4;
          }
          if ((splinef & 4) != 0) {
            // Read bias
            getFloat();
            offset += 4;
          }
          if ((splinef & 8) != 0) {
            // Read ease to
            getFloat();
            offset += 4;
          }
          if ((splinef & 16) != 0) {
            // Read ease from
            getFloat();
            offset += 4;
          }

          // Read this key pos (global coordinate
          x = getFloat();
          y = getFloat();
          z = getFloat();
          if (xKey == 0) this.key3DTrans[cObjetId] = new Point3D(x, z, y);

          cPosition.set(x, z, y);
          Point3D position = new Point3D();
          position.copy(cPosition);
          /*
          if(cObjetId!=-1)
          {

          	System.out.println(tObjets3D[cObjetId].getName());
          	System.out.println("pos="+position.toString());
          }
          */

          this.animators[cObjetId].addKeyPosition(nKey * 30, position);
          lastPosition.copy(cPosition);

          offset += 12;
        }
        break;

      case KEYFROT:
        int infor = getShort();
        offset += 2;
        for (int niu = 0; niu < 8; niu++) {
          byte infoUnknow = (byte) getByte();
          offset += 1;
        }
        int nbKeyr = (int) getUInt();
        offset += 4;

        Axis3D cAxis = new Axis3D();
        cAxis.init();
        Point3D cRotation = new Point3D();
        Point3D lastRotation = new Point3D();

        if (this.animators[cObjetId] == null)
          this.animators[cObjetId] = new Scene3DObjectAnimator();

        for (int xKey = 0; xKey < nbKeyr; xKey++) {
          int nKey = (int) getUInt();

          offset += 4;
          int infoAcceleration = getShort();
          offset += 2;
          double a = getFloat();
          offset += 4;
          x = getFloat();
          y = getFloat();
          z = getFloat();

          if (a > Math.PI && xKey != 0) a = 2.0 * Math.PI - a;

          if (xKey == 0) {
            this.key3DRotAng[cObjetId] = a;
            this.key3DRotAxe[cObjetId] = new Point3D(x, z, y);
          }

          cAxis.rotate(a, -x, -z, -y);
          cAxis.getRotationXZY(cRotation);

          Point3D rotation = new Point3D();
          rotation.copy(cRotation);

          this.animators[cObjetId].addKeyRotation(nKey * 30, rotation, new Point3D(-x, -z, -y), a);

          offset += 12;
        }

        break;

      case KEYFZOOM:
        int infoz = getShort();
        offset += 2;
        for (int niu = 0; niu < 8; niu++) {
          byte infoUnknow = (byte) getByte();
          offset += 1;
        }
        int nbKeyz = (int) getUInt();
        offset += 4;
        for (int xKey = 0; xKey < nbKeyz; xKey++) {
          int nKey = (int) getUInt();
          offset += 4;
          int infoAcceleration = getShort();
          offset += 2;
          x = getFloat();
          y = getFloat();
          z = getFloat();
          if (xKey == 0) this.key3DZoom[cObjetId] = new Point3D(x, z, y);
          offset += 12;
        }
        break;

      case KEYFCAMFOVFRAME:
        int infof = getShort();
        offset += 2;
        for (int niu = 0; niu < 8; niu++) {
          byte infoUnknow = (byte) getByte();
          offset += 1;
        }
        int nbKeyf = (int) getUInt();
        offset += 4;
        for (int xKey = 0; xKey < nbKeyf; xKey++) {
          int nKey = (int) getUInt();
          offset += 4;
          int infoAcceleration = getShort();
          offset += 2;
          float fov = getFloat();
          if (this.cObjet instanceof Camera3D) {
            ((Camera3D) this.cObjet).setFOV(fov);
          }

          offset += 4;
        }
        break;

      case KEYFPIVOT:
        x = getFloat();
        y = getFloat();
        z = getFloat();
        offset += 12;
        this.cObjet.pivot.set(x, z, y);
        break;

      case KEYFBOX:
        double x1 = getFloat();
        double y1 = getFloat();
        double z1 = getFloat();
        offset += 12;
        double x2 = getFloat();
        double y2 = getFloat();
        double z2 = getFloat();
        offset += 12;
        this.cObjet.center.set((x1 + x2) * 0.5, (z1 + z2) * 0.5, (y1 + y2) * 0.5);
        break;

      case KEYF3DS:
        this.isKeyFrame = true;
        // System.out.println("KEYF3DS");
        this.cObjetId = 0;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFHEADERACTIVE:
        long startf = getUInt();
        long endf = getUInt();
        // System.out.println("KEYFRAME START FRAME="+ startf);
        // System.out.println("KEYFRAME END FRAME="+ endf);
        offset += 8;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFHEADERCURRENT:
        long currentf = getUInt();
        // System.out.println("KEYFRAME CURRENT FRAME="+currentf);
        offset += 4;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFHEADERGLOBAL:
        this.keyFrameRevision = getShort();
        this.keyFrameFileName = getString();
        this.KeyFrameNbFrame = getUInt();
        offset += 2;
        offset += this.keyFrameFileName.length() + 1;
        offset += 4;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case MAIN3DS:
        this.cObjetId = 0;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case EDIT3DS:
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFOBJFRAME:
        this.cObjetId++;
        while (offset < longueur) offset += decodeChunk(prof + 1);
        break;

      case KEYFCAMFRAME:
        this.cObjetId++;
        // System.out.println("-----CAMERA-------");
        // System.out.println("ID1="+cObjetId);
        while (offset < longueur) offset += decodeChunk(prof + 1);
        // System.out.println("-----END CAMERA-------");
        break;

      case KEYFCAMTARGETFRAME:
        this.cObjetId++;
        // System.out.println("-----CAMERA TARGET-------");
        // System.out.println("ID1="+cObjetId);
        // MUST DO SPECIAL DECODE OF CHILD TO NOT OVERWRITE CAMERA TRACK POS/ROT

        // while(offset<longueur)
        //	offset+=decodeChunk(prof+1);
        // System.out.println("-----END CAMERA TARGET-------");
        break;

      default:
        break;
    }
    this.setProgress(50 + (50 * this.nbBytesDecoded) / this.data.length);
    skip(id, offset, longueur - offset);
    this.popChunk();
    return longueur;
  }
コード例 #7
0
ファイル: Atan.java プロジェクト: PrinzEugen7/Statistics
 public static void main(String[] args) {
   double deg = 30;
   double rad = Math.toRadians(deg);
   double ans = Math.atan(rad);
   System.out.println(ans);
 }
コード例 #8
0
 /**
  * Calculate Cumulative Cauchy distribution function.
  *
  * @return the probability that a stochastic variable x is less than X
  * @author Klaus Meffert
  * @since 1.1
  */
 public double nextCauchy() {
   return 0.5 + Math.atan((m_rn.nextDouble() - m_location) / m_scale) / Math.PI;
 }