package myfirstmap;
import com.mapinfo.mapj.MapJ;
import com.mapinfo.unit.LinearUnit;
import com.mapinfo.util.DoublePoint;
import com.mapinfo.util.DoubleRect;
import com.mapinfo.dp.tab.TABDataProviderHelper;
import com.mapinfo.dp.tab.TABTableDescHelper;
import com.mapinfo.mapxtreme.client.MapXtremeDataProviderRef;
import com.mapinfo.mapj.AbstractLayer;
import com.mapinfo.mapj.Layers;
//import com.mapinfo.mapj.Layer;
import com.mapinfo.mapj.FeatureLayer;
import com.mapinfo.dp.TableInfo;
import java.util.List;
import java.util.ArrayList;
import com.mapinfo.dp.util.RewindableFeatureSet;
import com.mapinfo.dp.FeatureSet;
import com.mapinfo.dp.Feature;
import com.mapinfo.dp.Attribute;
import com.mapinfo.dp.Geometry;
import com.mapinfo.dp.PointGeometry;
import com.mapinfo.dp.VectorGeometry;
import com.mapinfo.dp.PointList;
import com.mapinfo.mapj.FeatureFactory;
import com.mapinfo.graphics.Rendition;
import  com.mapinfo.graphics.RenditionImpl;
import java.awt.Color;
import com.mapinfo.dp.annotation.AnnotationDataProvider;
import com.mapinfo.dp.annotation.AnnotationDataProviderHelper;
import com.mapinfo.dp.annotation.AnnotationTableDescHelper;
import com.mapinfo.dp.util.LocalDataProviderRef;
import com.mapinfo.dp.PrimaryKey;
import com.mapinfo.mapxtreme.client.MapXtremeImageRenderer;
import com.mapinfo.xmlprot.mxtj.ImageRequestComposer;
import com.mapinfo.dp.AttOperator;
import com.mapinfo.dp.AttTuple;
import com.mapinfo.dp.QueryParams;
public class FeatureClass
{
  private   String mapxtremeURL="http://901-32:8083/mapxtreme47/mapxtreme";
  private   String mdfFilePath="E:\\MapInfo\\study\\mapmdf\\pla2.mdf";
  public FeatureClass()
  {
  }
  public  void getInfoFromFeature()
  {
   MapJ mapj=new MapJ();
   DoublePoint point=new DoublePoint(018.9608,34.2729);
   DoubleRect bound=new DoubleRect(point,0.31,0.21);
   mapj.setBounds(bound) ;
   LinearUnit unit=LinearUnit.kilometer ;
   mapj.setDistanceUnits(unit) ;
   mapj.setDeviceBounds(new DoubleRect(0,0,800,600)) ;
   //
  try
  {
    mapj.loadMapDefinition(mdfFilePath);
    Layers layers=mapj.getLayers() ;
    AbstractLayer abstractLayer=null;
    FeatureLayer featureLayer=null;
    String layerName;
    TableInfo tableInfo=null;
    List columns=new ArrayList();
    Attribute attribute=null;
    Geometry geom=null;
    PointGeometry pointGeom=null;
    int attributeCount=0;
    DoubleRect rect=null;
    DoublePoint dbPoint=null;
    PointList pointList=null;
    VectorGeometry vectorGeometry=null;
    int count=0;
    for(int i=0;i<layers.size() ;i++)
    {
      featureLayer=(FeatureLayer)layers.get(i) ;
      layerName=featureLayer.getName() ;
      tableInfo=featureLayer.getTableInfo() ;
      //必須清空，因為下次執行下一個表時，如果它們的字段不一樣，那么在“FeatureSet fSet=featureLayer.searchAll(columns,null);”就會出現錯誤
      count=0;
      columns.clear() ;
      for(int j=0;j<tableInfo.getColumnCount() ;j++)
      {
        String columnName=tableInfo.getColumnName(j) ;
        columns.add(columnName) ;
      }
      //perform a search to get the features(records) from the layer
      FeatureSet fSet=featureLayer.searchAll(columns,null);
      RewindableFeatureSet rfSet=new RewindableFeatureSet(fSet);
      //get the first attribute
      Feature feature=rfSet.getNextFeature() ;
      //the loop throuth all feature in the layer
      while(feature!=null)
      {
        /* get the first attribute (columnData) from the feature Note: If
        we want to re-use the Attribute object later on (after the
        getNextFeature loop), we would need to make a copy of the
        Attribute object, using the copy constructor.
        */
        attribute=feature.getAttribute(0) ;//it's error here
        //get a count of all attributes in the layer
        attributeCount=feature.getAttributeCount() ;
        //get a reference to the grographic information from the feature
        geom=feature.getGeometry() ;
        //if the geometry is a point
        if(geom.getType() ==Geometry.TYPE_POINT )
        {
          pointGeom=(PointGeometry)geom;
          // get the minimum bounding rectangle for the feature
          rect=pointGeom.getBounds() ;
          // get the x,y location where the feature’s label will be
          // anchored
          dbPoint=pointGeom.getLabelPoint(null);
        }else
        {
          vectorGeometry = (VectorGeometry) geom;

          rect = vectorGeometry.getBounds();
          dbPoint = vectorGeometry.getLabelPoint(null);
          double[] points;
          int offset=0;
          int numPoints;
           int pointListCount=vectorGeometry.getPointListCount() ;
          for (int ii=0;ii<vectorGeometry.getPointListCount();++ii)
          {
            // Get the next Point List
            pointList = vectorGeometry.getNextPointList();
            // determine the number of Points in the point group
             numPoints = pointList.getPointCount();
            // Create the point array large enough to hold all the
            // points
            points = new double[numPoints];
            // Call getNextPoints which will put the points into the
            // array
            pointList.getNextPoints(points, offset, numPoints/2);
           }//end this for above
        }//end else
       count++;
        if((count>332)&&(layerName.equals("Line") ))
       {
         System.out.println(">99") ;
       }
       feature=rfSet.getNextFeature() ;
      }//end while
      //rewind the featureSet for the future use
      rfSet.rewind() ;
    }//end the most outer for
  }catch(java.io.IOException  ioe)
  {
    System.out.println("get a "+ioe.getClass() +"\nwith message "+ioe.getMessage() ) ;
    ioe.printStackTrace() ;
  }catch(Exception e)
  {
    System.out.println("get a "+e.getClass() +"\nwith message "+e.getMessage() ) ;
    e.printStackTrace() ;
  }
}//end this function

public void createVariousFeature()
{
  MapJ mapj=new MapJ();
  DoublePoint point=new DoublePoint(108.9608,34.2729);
  DoubleRect bound=new DoubleRect(point ,0.31,0.21);
  mapj.setBounds(bound) ;
  LinearUnit unit=LinearUnit.kilometer ;
  mapj.setDistanceUnits(unit) ;
  mapj.setDeviceBounds(new DoubleRect(0,0,800,600)) ;
  try
  {
  //  mapj.loadMapDefinition(mdfFilePath);
    FeatureFactory feaFac=mapj.getFeatureFactory() ;
    //set attribute object
    Attribute[] attributes=new Attribute[4];
    attributes[0]=new Attribute("feature1");
    attributes[1]=new Attribute("ellpise");
    attributes[2]=new Attribute("point");
    attributes[3]=new Attribute("polyline");
    //set up the rendition object
    //this will not work for a tab files. for tab files we must use
    //com.mapinfo.tab.TABStyleFactory to create an appropirate rendition object
    Rendition rend=RenditionImpl.getDefaultRendition() ;
    //for circle ,specify the edge color and fill color
    rend.setValue(Rendition.STROKE ,Color.cyan );
    rend.setValue(Rendition.FILL ,Color.green );
    // For points, specify the symbol size, font, and color
    rend.setValue(Rendition.SYMBOL_STRING, "@");
    rend.setValue(Rendition.FONT_SIZE, 16);
    rend.setValue(Rendition.FONT_FAMILY, "MapInfo Shields");
    rend.setValue(Rendition.SYMBOL_FOREGROUND, Color.blue);
// For lines, specify the line color and width
    rend.setValue(Rendition.STROKE, Color.green);
    rend.setValue(Rendition.STROKE_WIDTH, 4);
// For ellipses, specify the fill color and opacity
    rend.setValue(Rendition.FILL, Color.blue);
    rend.setValue(Rendition.FILL_OPACITY, new Float(0.40));

    //create circular region
    int circleType=1;
     double circleRadius=2;
    int circleResolution=12;
    //for elliptical region
    //create a integer variable to set the coordsys system of the region.o set for map coordsys,1 set for screen coordsys
    int ellipseType=1;
    //create a variable to set the rotation angle of the ellipse in radiant
    double xRadius=1.0;
    double yRadius=0.25;
    //create a integer variable to specify the number of point to describe the ellipse. if 0,the default 12 will be used
    int ellipseResolution=12;
    //create an annotation layer for storing the feature we are creating
    AnnotationTableDescHelper annotationTDHelper=new AnnotationTableDescHelper("Annotations");
    AnnotationDataProviderHelper annotationDPHelper=new AnnotationDataProviderHelper();
    LocalDataProviderRef localDPRef=new LocalDataProviderRef(annotationDPHelper);
    FeatureLayer annotationLayer=(FeatureLayer)mapj.getLayers() .insertLayer(localDPRef,annotationTDHelper,0,"Annotations");
    //PrimaryKey is taken as an argument by all the create methods and
//cannot be null
    Feature retFeature;
    PrimaryKey pkey = new PrimaryKey(attributes[0]);
    //set the center point for the circle
    DoublePoint centerPoint=new DoublePoint(108.9608,34.2729);
    // Create a Circular Region
    retFeature = feaFac.createCircularRegion(circleType,//type
                                             /*
if the Type is 0, MapJ creates a region whose points are all the same geographic distance from the
 center. Due to the curvature of the earth, and due to the way that coordinate systems and
 map projections work, such a circle might appear lop-sided, rather than circular.
If the type parameter is 1, MapJ creates a region that appears circular on the screen.
However, different points on the circle might not be the same geographic distance from the center
of the circle.
type - An integer representing the type of coordinate system to use in creation of the circle.
Use 0 for map coords and 1 for screen coords.
*/
centerPoint,// The center of the circle given as a DoublePoint.
circleRadius,//the radius of the circle
LinearUnit.mile,//the linear unit of the distance
circleResolution,// The number of points describing the circle. If 0 it will use default of 12.
rend,//The rendition associated with this feature, may be null.
null, //The rendition associated with the label for this feature, may be null.
null,//attributes,//Attributes that are associated with this feature, may be null.
pkey//the PrimaryKey of the new Feature, may be null.
);
    //add the new feature to the annotation layer
    PrimaryKey pkey2=annotationLayer.addFeature(retFeature) ;
//create the ellipse region
DoublePoint    ellipseCenter=new DoublePoint(108.9608,34.3729);
retFeature=feaFac.createEllipticalRegion(ellipseType,ellipseCenter,0,xRadius,yRadius,
   LinearUnit.mile  , ellipseResolution,rend,null,null,new PrimaryKey(attributes[1]));
  annotationLayer.addFeature(retFeature) ;
//creae point
retFeature=feaFac.createPoint(new DoublePoint(108.8,34.2729),rend,null,new PrimaryKey(attributes[2]));
  annotationLayer.addFeature(retFeature) ;
//create ployline
  // Create PolyLine using a 2 x 6 double matrix
// Row 1 contains 3 points(x,y,x,y,x,y) and 2 line segments.
// Row 2 contains 3 points(x,y,x,y,x,y) and 2 line segments.
double pts[][] = { {108.8608,34.2720, 108.8908,34.2720,108.9208,34.270},
      {108.8908,34.2680, 108.8608,34.2680,108.8408,34.2720} };
retFeature = feaFac.createPolyLine(pts, rend, null, null, new PrimaryKey(attributes[3]));
  annotationLayer.addFeature(retFeature) ;
     //
     MapXtremeImageRenderer render=new MapXtremeImageRenderer(mapxtremeURL);
     ImageRequestComposer imageRC=ImageRequestComposer.create(mapj,256,Color.white ,"image/png");
     render.render(imageRC) ;
     render.toFile("E:\\MapInfo\\study\\png\\created.png") ;
  }catch(Exception e)
  {
    System.out.println("get a "+e.getClass() +"\nwith message "+e.getMessage() ) ;
    e.printStackTrace() ;
  }
}
public void searchFeature()
{
  MapJ mapj=new MapJ();
  DoublePoint centerPoint=new DoublePoint(108.9608,34.2729);
  DoubleRect bound=new DoubleRect(centerPoint,0.31,0.21);
  mapj.setBounds(bound) ;
  mapj.setDeviceBounds(new DoubleRect(0,0,800,600)) ;
  Layers layers=null;
  FeatureLayer featureLayer;
  FeatureSet featureSet=null;
  double searchRadius=2;
  List resList=new ArrayList();
  RewindableFeatureSet rfSet=null;
  Feature feature=null;
  try
  {
    mapj.loadMapDefinition(mdfFilePath);
    layers=mapj.getLayers() ;
    int count=0;
    String layerName;
    for(int i=0;i<layers.size() ;i++)
    {
      featureLayer=(FeatureLayer)layers.get(i) ;
      layerName=featureLayer.getName() ;
      feature=null;
      count=0;
//      featureSet=featureLayer.searchWithinRadius(resList,centerPoint,searchRadius,LinearUnit.kilometer ,null);
  //  DoubleRect rect=new DoubleRect(108.9608,34.2729,108.9908,34.3729);
  //    featureSet=featureLayer.searchWithinRectangle(resList,rect,null);
   //   featureSet=featureLayer.searchAtPoint(resList,centerPoint,null) ;
    /*  Attribute attLength=new Attribute(1022);
      String searchCol="length";

      if(layerName.equals("line") )
      {
      featureSet=featureLayer.searchByAttribute(resList,searchCol,attLength,null);
      rfSet=new RewindableFeatureSet(featureSet);
      feature=rfSet.getNextFeature() ;
      }*/
      int searchLen=1022;
      String searchColumn="length";
      //create name list
      List nameList=new ArrayList();
      nameList.add(searchColumn) ;
      //create value list
      List valueList=new ArrayList();
      Attribute searchAttr=new Attribute(searchLen);
      AttTuple searchTuple=new AttTuple(searchAttr);
      valueList.add(searchTuple);
      //create operator list
      List operatorList=new ArrayList();
      operatorList.add(AttOperator.eq ) ;
      //do the search
      if(layerName.equals("line") )
      {
      featureSet=featureLayer.searchByAttributes(resList,nameList,operatorList,valueList,QueryParams.m_defaultQP );
      rfSet=new RewindableFeatureSet(featureSet);
      feature=rfSet.getNextFeature() ;
      //下面這個是練習，練習如何得到feature對應的列值，因為一個層實際上對應的就是一個表，所以一個feature
         //對應的應該就是一列
         for(int ii=0;ii<feature.getAttributeCount() ;ii++)
         {
           Attribute att=feature.getAttribute(ii) ;
           String str=att.getString() ;
           str="wait";
         }

      }

      while(feature!=null)
      {
        count++;
        feature=rfSet.getNextFeature() ;
        //下面這個是練習，練習如何得到feature對應的列值，因為一個層實際上對應的就是一個表，所以一個feature
       //對應的應該就是一列
       for(int ii=0;ii<feature.getAttributeCount() ;ii++)
       {
         Attribute att=feature.getAttribute(ii) ;
         String str=att.getString() ;
         str="wait";
       }

      }
      System.out.println("there are "+count+" in "+layerName+" layer ") ;
    }
  }catch(java.io.IOException  ioe)
  {
    System.out.println("get a  "+ioe.getClass() +"\nwith message "+ioe.getMessage() ) ;
  }catch(Exception e)
  {
    System.out.println("get a "+e.getClass() +"\nwith message "+e.getMessage() ) ;
  }
}
}