Package org.krysalis.jcharts.properties

Examples of org.krysalis.jcharts.properties.PieChart3DProperties


   * Draws the chart
   *
   ************************************************************************************************/
  protected void renderChart()
  {
    PieChart3DProperties properties = (PieChart3DProperties) this.iPieChartDataSet.getChartTypeProperties();
    FontRenderContext fontRenderContext = super.getGraphics2D().getFontRenderContext();

    this.pieChartDataProcessor = new PieChartDataProcessor( this.iPieChartDataSet );
    this.pieChartDataProcessor.processData();


    //---cache calcs used more than once
    float edgePaddingTimesTwo = super.getChartProperties().getEdgePadding() * 2;
    float halfImageWidth = super.getImageWidth() / 2;
    float halfImageHeight = super.getImageHeight() / 2;


    //---render the TITLE. If no title, this will return zero.
    float chartTitleHeightPlusPadding = super.renderChartTitle( this.iPieChartDataSet.getChartTitle(), fontRenderContext );


    //---figure out what size is needed to hold all the components of the pie chart, then size the pie accordingly
    float widthAvailable = super.getImageWidth() - edgePaddingTimesTwo;

    float heightAvailable = super.getImageHeight() - edgePaddingTimesTwo;
    heightAvailable -= chartTitleHeightPlusPadding;
    heightAvailable -= properties.getDepth();


    //---take labels sizing into consideration if needed.
    if( !properties.getPieLabelType().equals( PieLabelType.NO_LABELS ) )
    {
      this.pieLabels = new PieLabels( properties, this.iPieChartDataSet, fontRenderContext );

      //---if there is only one item in pie, label will be below plot so width is not a concern
      if( iPieChartDataSet.getNumberOfDataItems() != 1 )
      {
        widthAvailable -= this.pieLabels.getWidestLabelTimesTwo();
        widthAvailable -= ( properties.getTickLength() * 2 );
      }

      heightAvailable -= this.pieLabels.getTallestLabelTimesTwo();
      heightAvailable -= ( properties.getTickLength() * 2 );
    }


    //---if there is a legend...
    if( this.getLegend() != null )
    {
      float legendX = 0f;
      float legendY = 0f;

      //---calculate all the legend rendering coordinates and positions.
      this.getLegend().calculateDrawingValues( iPieChartDataSet );


      //---adjust width and height based on the Legend size.
      if( ( this.getLegend().getLegendProperties().getPlacement() == LegendAreaProperties.RIGHT )
        || ( this.getLegend().getLegendProperties().getPlacement() == LegendAreaProperties.LEFT ) )
      {
        widthAvailable -= this.getLegend().getWidth();
        widthAvailable -= this.getLegend().getLegendProperties().getChartPadding();

        //---diameter of pie will be at least one pixel, even if the legend takes up the whole image.
        //---this will keep the renderer from blowing up.
        this.diameter = Math.max( widthAvailable, 1.0f );

        //---make sure we do not make the pie diameter taller than the image
        this.diameter = Math.min( this.diameter, heightAvailable );

        this.pie3dWidth = this.diameter;
        this.pie3dHeight = this.pie3dWidth * RATIO;


/*
this.pie3dWidth= 200;
this.pie3dHeight= 200;
*/


        //---calculate the entire width of everything to be drawn so can center everything
        float plotWidth = this.diameter;
        plotWidth += this.getLegend().getWidth();
        plotWidth += this.getLegend().getLegendProperties().getChartPadding();
        if( this.pieLabels != null )
        {
          plotWidth += ( this.pieLabels.getWidestLabel() * 2 );
          plotWidth += ( properties.getTickLength() * 2 );
        }

        if( this.getLegend().getLegendProperties().getPlacement() == LegendAreaProperties.RIGHT )
        {
          //---pie's diameter may not fill image width as may be image height constrained.
          this.pieX = halfImageWidth - ( plotWidth / 2 );

          if( this.pieLabels != null )
          {
            this.pieX += this.pieLabels.getWidestLabel();
            this.pieX += properties.getTickLength();
            legendX += this.pieLabels.getWidestLabel();
            legendX += properties.getTickLength();
          }

          //---position legend based on the pie position
          legendX += this.pieX + this.diameter;
          legendX += this.getLegend().getLegendProperties().getChartPadding();
        }
        else
        {
          legendX = halfImageWidth - ( plotWidth / 2 );

          if( this.pieLabels != null )
          {
            this.pieX = legendX;
            this.pieX += this.getLegend().getWidth();
            this.pieX += this.getLegend().getLegendProperties().getChartPadding();
            this.pieX += this.pieLabels.getWidestLabel();
            this.pieX += properties.getTickLength();
          }
        }

        //---center the legend vertically
        legendY = halfImageHeight - ( this.getLegend().getHeight() / 2 );

        //---center the pie vertically
        this.pieY = halfImageHeight - ( ( this.pie3dHeight + properties.getDepth() ) / 2 );
      }
      //---else the legend is either under or on top of the pie
      else
      {
        heightAvailable -= this.getLegend().getHeight();
        heightAvailable -= this.getLegend().getLegendProperties().getChartPadding();

        //---diameter of pie will be at least one pixel, even if the legend takes up the whole image.
        //---this will keep the renderer from blowing up.
        this.diameter = Math.max( heightAvailable, 1.0f );

        //---make sure we do not make the pie diameter wider than the image
        this.diameter = Math.min( this.diameter, widthAvailable );

        this.pie3dWidth = this.diameter;
        this.pie3dHeight = this.pie3dWidth * RATIO;


        if( this.getLegend().getLegendProperties().getPlacement() == LegendAreaProperties.BOTTOM )
        {
          this.pieY = super.getChartProperties().getEdgePadding();
          this.pieY += chartTitleHeightPlusPadding;

          if( this.pieLabels != null )
          {
            //---adds label height from top of pie
            this.pieY += this.pieLabels.getTallestLabel();
            this.pieY += properties.getTickLength();

            //---add label hight from bottom of pie
            legendY += this.pieLabels.getTallestLabel();
            legendY += properties.getTickLength();
          }

          legendY += this.pieY;
          legendY += this.pie3dHeight;
          legendY += this.getLegend().getLegendProperties().getChartPadding();
          legendY += properties.getDepth();
        }
        else
        {
          legendY = super.getChartProperties().getEdgePadding();
          legendY += chartTitleHeightPlusPadding;

          this.pieY = legendY;
          this.pieY += this.getLegend().getHeight();
          this.pieY += this.getLegend().getLegendProperties().getChartPadding();

          if( this.pieLabels != null )
          {
            //---adds label height from top of pie
            this.pieY += this.pieLabels.getTallestLabel();
            this.pieY += properties.getTickLength();
          }
        }

        //---center the legend horizontally
        legendX = halfImageWidth - ( this.getLegend().getWidth() / 2 );

        //---center the pie horizontally
        this.pieX = halfImageWidth - ( this.diameter / 2 );
      }

      super.getLegend().setX( legendX );
      super.getLegend().setY( legendY );
      super.getLegend().render();

    }
    //---else, the Legend is NULL
    else
    {
      //---diameter of pie will be at least one pixel, even if the legend takes up the whole image.
      //---this will keep the renderer from blowing up.
      this.diameter = Math.max( widthAvailable, 1.0f );

      //---make sure we do not make the pie diameter taller than the image
      this.diameter = Math.min( this.diameter, heightAvailable );

      this.pie3dWidth = this.diameter;
      this.pie3dHeight = this.pie3dWidth * RATIO;


      //---if there is no legend, fill the image with the pie
      //this.diameter = Math.min( heightAvailable, widthAvailable );

      float halfDiameter = ( this.diameter + properties.getDepth() ) / 2;

      //---center the pie horizontally
      this.pieX = halfImageWidth - halfDiameter;

      //---center the pie vertically
      //this.pieY = halfImageHeight - halfDiameter;

      this.pieY = halfImageHeight - ( ( this.pie3dHeight + properties.getDepth() ) / 2 );
    }


    //---IMAGE MAP setup
    //---if we are saving all the coordinates for an ImageMap, create the ImageMap Object as we
View Full Code Here


   * @param pieChart3D
   ************************************************************************************************/
  static void render( PieChart3D pieChart3D )
  {
    Graphics2D g2d = pieChart3D.getGraphics2D();
    PieChart3DProperties properties = (PieChart3DProperties) pieChart3D.iPieChartDataSet.getChartTypeProperties();


    //---the following only for Image Map-----------------------------
    //---IMAGE MAP
    //---number of subdivisions to break each slice into to 'fill' slice
    int subdivisions = 3;
    float halfDiameter = 0;
    float xPieMiddle = 0;
    float yPieMiddle = 0;
    float imageMapPoints[][] = null;
    if( pieChart3D.getImageMap() != null )
    {
      halfDiameter = (float) ( pieChart3D.diameter / 2.0 );
      xPieMiddle = halfDiameter + pieChart3D.pieX;
      yPieMiddle = halfDiameter + pieChart3D.pieY;
      imageMapPoints = new float[pieChart3D.iPieChartDataSet.getNumberOfDataItems() * ( subdivisions + 1 )][2];
    }


    //---get the starting degree
    float currentDegrees = properties.getZeroDegreeOffset();

    double percentageOfPie = 0;



    //---if only one item in chart, just draw border around outside.
    //---if do a draw of the arc, will get a line in the pie as arc has a start and end.
    if( pieChart3D.iPieChartDataSet.getNumberOfDataItems() == 1 )
    {
      Arc2D.Double arc = new Arc2D.Double( pieChart3D.pieX,
                               pieChart3D.pieY + properties.getDepth(),
                               pieChart3D.diameter,
                               pieChart3D.diameter,
                               currentDegrees,
                               360,
                               Arc2D.OPEN );


      //---fake 3d loop will slide pie up the image to give illusion of 3D.
      for( int i = properties.getDepth(); i >= 0; i-- )
      {
        g2d.setPaint( pieChart3D.iPieChartDataSet.getPaint( 0 ) );
        g2d.fill( arc );

        if( i == properties.getDepth() || i == 0 )
        {
          properties.getBorderChartStroke().draw( g2d, arc );
        }

        arc.y -= 1;
      }


      //---if only a single value use a circle map
      //---IMAGE MAP
      if( pieChart3D.getImageMap() != null )
      {
        CircleMapArea circleMapArea = new CircleMapArea( xPieMiddle, yPieMiddle, pieChart3D.iPieChartDataSet.getValue( 0 ), null, pieChart3D.iPieChartDataSet.getLegendLabel( 0 ) );
        circleMapArea.setRadius( (int) pieChart3D.diameter );
        pieChart3D.getImageMap().addImageMapArea( circleMapArea );
      }

//      System.out.println( pieChart3D.pieLabels.getTextTag( 0 ).getText() );

      float x = pieChart3D.pieX + ( pieChart3D.diameter / 2 ) - ( pieChart3D.pieLabels.getTextTag( 0 ).getWidth() / 2 );
      float y = pieChart3D.pieY - properties.getTickLength();
//      System.out.println( "x=" + x );
//      System.out.println( "y=" + y );

      properties.getValueLabelFont().setupGraphics2D( g2d );
      g2d.drawString( pieChart3D.pieLabels.getTextTag( 0 ).getText(), x, y );
    }
    else
    {
      Arc2D.Double arc = new Arc2D.Double( pieChart3D.pieX,
                               pieChart3D.pieY + properties.getDepth(),
                               pieChart3D.pie3dWidth,
                               pieChart3D.pie3dHeight,
                               currentDegrees,
                               360,
                               Arc2D.PIE );


      //---draw the center line in case people are using transparent paint
      Line2D.Float line = new Line2D.Float();
      line.x1 = pieChart3D.pieX + ( pieChart3D.pie3dWidth / 2 );
      line.y1 = pieChart3D.pieY + ( pieChart3D.pie3dHeight / 2 );
      line.x2 = line.x1;
      line.y2 = line.y1 + properties.getDepth();
      properties.getBorderChartStroke().draw( g2d, line );


      //---fake 3d loop will slide pie up the image to give illusion of 3D.
      for( int slider = properties.getDepth(); slider >= 0; slider-- )
      {
        currentDegrees = properties.getZeroDegreeOffset();

        //---IMAGE MAP
        int mapCounter = 0;

        for( int i = 0; i < pieChart3D.iPieChartDataSet.getNumberOfDataItems(); i++ )
        {
          percentageOfPie = pieChart3D.pieChartDataProcessor.getPercentageOfPie( i );

          arc.setAngleStart( currentDegrees );
          arc.setAngleExtent( percentageOfPie );

          //---set the color, and fill the pie piece.
          g2d.setPaint( pieChart3D.iPieChartDataSet.getPaint( i ) );
          g2d.fill( arc );


          //---renders borders
          drawFraming( slider, properties, g2d, arc, currentDegrees );


          //---if we are going to display labels
          if( pieChart3D.pieLabels != null && slider == 0 )
          {
            //---get the angle the center of slice
            double sliceCenterDegrees = ( currentDegrees ) + percentageOfPie / 2;

            if( sliceCenterDegrees > 360 )
            {
              sliceCenterDegrees -= 360;
            }



//            double sliceCenterRadians = Math.toRadians( sliceCenterDegrees );


/*

>a2 := a * a;
>b2 := b * b;
>sin2 := Sqr (Sin(theta));
>cos2 := Sqr(Cos(theta));
>r = Sqrt( a2 * b2 / (a2 * sin2 + b2 * cos2) );
*/
/*
            double a2 = pieChart3D.pie3dWidth * pieChart3D.pie3dWidth;
            double b2 = pieChart3D.pie3dHeight * pieChart3D.pie3dHeight;
            double sin2 = Math.pow( Math.sin( sliceCenterRadians ), 2 );
            double cos2 = Math.pow( Math.cos( sliceCenterRadians ), 2 );
            double radius = pieChart3D.pie3dWidth * pieChart3D.pie3dHeight / Math.sqrt( ( a2 * sin2 + b2 * cos2 ) );
            radius /= 2;


            //r= (ab) / ( sqrt( a^2 sin^2 theta + b^2 cos^2 theta ) )

            //---compute the cos and sin of the label angle.
            double cosOfLabel = Math.cos( sliceCenterRadians );
            double sinOfLabel = Math.sin( sliceCenterRadians );

            //halfDiameter = (float) ( pieChart3D.diameter / 2.0 );


            //---start point of the label border line.
            float borderXstart = (float) ( cosOfLabel * radius );
            float borderYstart = (float) -( sinOfLabel * radius );

            //---end point of the label border line.
            float borderXend = (float) ( cosOfLabel * ( radius + properties.getTickLength() ) );
            float borderYend = (float) -( sinOfLabel * ( radius + properties.getTickLength() ) );
*/


            xPieMiddle = (float) arc.x + pieChart3D.pie3dWidth / 2;
            yPieMiddle = (float) arc.y + pieChart3D.pie3dHeight / 2;


            Arc2D.Double circle = new Arc2D.Double( pieChart3D.pieX,
                                       pieChart3D.pieY,
                                       pieChart3D.pie3dWidth,
                                       pieChart3D.pie3dHeight,
                                       currentDegrees,
                                       percentageOfPie / 2,
                                       Arc2D.PIE );
            Arc2D.Double circle2 = new Arc2D.Double( pieChart3D.pieX - properties.getTickLength(),
                                        pieChart3D.pieY - properties.getTickLength(),
                                        pieChart3D.pie3dWidth + properties.getTickLength() * 2,
                                        pieChart3D.pie3dHeight + properties.getTickLength() * 2,
                                        currentDegrees,
                                        percentageOfPie / 2,
                                        Arc2D.PIE );

            //---draw the line out from middle of slice
            properties.getBorderChartStroke().draw( g2d, new Line2D.Float( circle.getEndPoint(), circle2.getEndPoint() ) );

            float borderXend = (float) circle2.getEndPoint().getX();
            float borderYend = (float) circle2.getEndPoint().getY();

            properties.getValueLabelFont().setupGraphics2D( g2d );


            float labelY = borderYend;
            if( sliceCenterDegrees > 60 && sliceCenterDegrees < 120 )
            {
              labelY -= pieChart3D.pieLabels.getTextTag( i ).getFontDescent();
            }
            else if( sliceCenterDegrees > 240 && sliceCenterDegrees < 300 )
            {
              labelY += pieChart3D.pieLabels.getTextTag( i ).getFontAscent();
            }


            if( sliceCenterDegrees > 180 && sliceCenterDegrees < 360 )
            {
              labelY+= properties.getDepth();
            }

            if( sliceCenterDegrees > 90 && sliceCenterDegrees < 270 )
            {
              g2d.drawString( pieChart3D.pieLabels.getTextTag( i ).getText(),
                         borderXend - pieChart3D.pieLabels.getTextTag( i ).getWidth() - properties.getTickLength(),
                         labelY );
            }
            else
            {
              g2d.drawString( pieChart3D.pieLabels.getTextTag( i ).getText(),
                         borderXend + properties.getTickLength(),
                         labelY );
            }
          }


View Full Code Here

                 new Color( 0, 200, 0, 20 ),
                 new Color( 0, 0, 200, 20 ),
                 new Color( 200, 200, 0, 20 ) };


    PieChart3DProperties pieChart3DProperties = new PieChart3DProperties();
    pieChart3DProperties.setPieLabelType( PieLabelType.LEGEND_LABELS );
    pieChart3DProperties.setTickLength( 5 );

    pieChart3DProperties.setZeroDegreeOffset( 60 );

    pieChart3DProperties.setDepth( 15 );


    LegendProperties legendProperties = null;
/*
    LegendProperties legendProperties = new LegendProperties();
View Full Code Here


  /******************************************************************************************/
  private void basicChart() throws Throwable
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    this.outputChart( pieChart3DProperties, "pieChart3DBasic" );
  }
View Full Code Here


  /******************************************************************************************/
  private void zeroDegreeOffsetChart() throws Throwable
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    pieChart3DProperties.setZeroDegreeOffset( 45f );
    this.outputChart( pieChart3DProperties, "pieChart3DZeroOffset" );
  }
View Full Code Here


  /******************************************************************************************/
  private void depth() throws Throwable
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    pieChart3DProperties.setDepth( 50 );
    this.outputChart( pieChart3DProperties, "pieChart3DDepth" );
  }
View Full Code Here


  /******************************************************************************************/
  private void borderStroke() throws Throwable
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    pieChart3DProperties.setBorderChartStroke( new ChartStroke( new BasicStroke( 4f ), Color.black ) );
    this.outputChart( pieChart3DProperties, "pieChart3DBorderStroke" );
  }
View Full Code Here

  }


  private void pieValueLabels() throws ChartDataException
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    pieChart3DProperties.setPieLabelType( PieLabelType.VALUE_LABELS );
    this.outputChart( pieChart3DProperties, "pieChart3DValueLabels" );
  }
View Full Code Here

    this.outputChart( pieChart3DProperties, "pieChart3DValueLabels" );
  }

  private void pieLegendLabels() throws ChartDataException
  {
    PieChart3DProperties pieChart3DProperties= new PieChart3DProperties();
    pieChart3DProperties.setPieLabelType( PieLabelType.LEGEND_LABELS );

    double[] data= { 81d, 55d, 39d, 20.6d };
    String[] labels= { "BMW M5", "BMW M3", "Viper GTS-R", "Audi S6" };
    Paint[] paints= { Color.lightGray, Color.green, Color.blue, Color.red };
View Full Code Here

    Paint[] paints = { Color.blue };
*/



    PieChart3DProperties pieChart3DProperties = new PieChart3DProperties();
    pieChart3DProperties.setPieLabelType( PieLabelType.LEGEND_LABELS );
    pieChart3DProperties.setTickLength( 5 );

    pieChart3DProperties.setZeroDegreeOffset( 60 );

    pieChart3DProperties.setDepth( 15 );

    LegendProperties legendProperties = new LegendProperties();
    legendProperties.setPlacement( LegendAreaProperties.RIGHT );
    legendProperties.setNumColumns( 1 );
    //legendProperties.setBorderStroke( null );
View Full Code Here

TOP

Related Classes of org.krysalis.jcharts.properties.PieChart3DProperties

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.