private void calculateVector() {
    /*
     * Notice that this tool assumes that each record in the shapefile is an
     * individual polygon. The feature can contain multiple parts only if it
     * has holes, i.e. islands. A multipart record cannot contain multiple
     * and seperate features. This is because it complicates the calculation
     * of feature area and perimeter.
     */

    amIActive = true;

    // Declare the variable.
    String inputFile = null;
    int progress;
    double featureArea = 0;
    double circleArea = 0;
    double radius = 0;
    int recNum;
    int j, i;
    double[][] vertices = null;
    CoordinateArraySequence coordArray;
    LinearRing ring;
    MinimumBoundingCircle mbc;
    GeometryFactory factory = new GeometryFactory();
    Geometry geom;

    if (args.length <= 0) {
      showFeedback("Plugin parameters have not been set.");
      return;
    }

    inputFile = args[0];
    /*
     * args[1], args[2], and args[3] are ignored by the vector tool
     */

    // check to see that the inputHeader and outputHeader are not null.
    if (inputFile == null) {
      showFeedback("One or more of the input parameters have not been set properly.");
      return;
    }

    try {

      ShapeFile input = new ShapeFile(inputFile);
      double numberOfRecords = input.getNumberOfRecords();

      if (input.getShapeType().getBaseType() != ShapeType.POLYGON) {
        showFeedback("This function can only be applied to polygon type shapefiles.");
        return;
      }

      /* create a new field in the input file's database
      to hold the fractal dimension. Put it at the end
      of the database. */
      DBFField field = new DBFField();
      field = new DBFField();
      field.setName("RC_CIRCLE");
      field.setDataType(DBFField.DBFDataType.NUMERIC);
      field.setFieldLength(10);
      field.setDecimalCount(4);
      input.getAttributeTable().addField(field);

      // initialize the shapefile.
      ShapeType inputType = input.getShapeType();

      for (ShapeFileRecord record : input.records) {
        switch (inputType) {
          case POLYGON:
            whitebox.geospatialfiles.shapefile.Polygon recPolygon =
                (whitebox.geospatialfiles.shapefile.Polygon) (record.getGeometry());
            vertices = recPolygon.getPoints();
            coordArray = new CoordinateArraySequence(vertices.length);
            j = 0;
            for (i = 0; i < vertices.length; i++) {
              coordArray.setOrdinate(j, 0, vertices[i][0]);
              coordArray.setOrdinate(j, 1, vertices[i][1]);
              j++;
            }
            geom = factory.createMultiPoint(coordArray);
            mbc = new MinimumBoundingCircle(geom);
            radius = mbc.getRadius();
            circleArea = Math.PI * radius * radius;
            featureArea = recPolygon.getArea();
            break;
          case POLYGONZ:
            PolygonZ recPolygonZ = (PolygonZ) (record.getGeometry());
            vertices = recPolygonZ.getPoints();
            coordArray = new CoordinateArraySequence(vertices.length);
            j = 0;
            for (i = 0; i < vertices.length; i++) {
              coordArray.setOrdinate(j, 0, vertices[i][0]);
              coordArray.setOrdinate(j, 1, vertices[i][1]);
              j++;
            }
            geom = factory.createMultiPoint(coordArray);
            mbc = new MinimumBoundingCircle(geom);
            radius = mbc.getRadius();
            circleArea = Math.PI * radius * radius;
            featureArea = recPolygonZ.getArea();
            break;
          case POLYGONM:
            PolygonM recPolygonM = (PolygonM) (record.getGeometry());
            vertices = recPolygonM.getPoints();
            coordArray = new CoordinateArraySequence(vertices.length);
            j = 0;
            for (i = 0; i < vertices.length; i++) {
              coordArray.setOrdinate(j, 0, vertices[i][0]);
              coordArray.setOrdinate(j, 1, vertices[i][1]);
              j++;
            }
            geom = factory.createMultiPoint(coordArray);
            mbc = new MinimumBoundingCircle(geom);
            radius = mbc.getRadius();
            circleArea = Math.PI * radius * radius;
            featureArea = recPolygonM.getArea();
            break;
        }

        recNum = record.getRecordNumber() - 1;
        Object[] recData = input.getAttributeTable().getRecord(recNum);
        if (circleArea > 0) {
          recData[recData.length - 1] = new Double(1 - featureArea / circleArea);
        } else {
          recData[recData.length - 1] = new Double(0);
        }
        input.getAttributeTable().updateRecord(recNum, recData);

        if (cancelOp) {
          cancelOperation();
          return;
        }
        progress = (int) (record.getRecordNumber() / numberOfRecords * 100);
        updateProgress(progress);
      }

      // returning the database file will result in it being opened in the Whitebox GUI.
      returnData(input.getDatabaseFile());

    } catch (OutOfMemoryError oe) {
      myHost.showFeedback("An out-of-memory error has occurred during operation.");
    } catch (Exception e) {
      myHost.showFeedback("An error has occurred during operation. See log file for details.");
      myHost.logException("Error in " + getDescriptiveName(), e);
    } finally {
      updateProgress("Progress: ", 0);
      // tells the main application that this process is completed.
      amIActive = false;
      myHost.pluginComplete();
    }
  }