示例#1
0
def scatterplot(data, name="", xlabel="", ylabel="", size= 3):
  """
  Creates a scatter plot from x,y data.

  *data* is a list of (x,y) tuples.
  """
    
  xAxis = NumberAxis(xlabel)   
  xAxis.setAutoRangeIncludesZero(False)   
  yAxis = NumberAxis(ylabel)   
  yAxis.setAutoRangeIncludesZero(False)   
   
  series = XYSeries("Values");     
  for (i,j) in data:         
    series.add(i, j)

  dataset = XYSeriesCollection()
  dataset.addSeries(series);
  chart = ChartFactory.createScatterPlot(name, xlabel, ylabel, dataset, 
    PlotOrientation.VERTICAL, True, True, False)    
  plot = chart.getPlot()
  plot.getRenderer().setSeriesShape(0, 
    ShapeUtilities.createRegularCross(size,size));                  
    
  return Chart(chart)
示例#2
0
def scatterplot(data, name="", xlabel="", ylabel="", size= 3):
  """
  Creates a scatter plot from x,y data.

  *data* is a list of (x,y) tuples.
  """
    
  xAxis = NumberAxis(xlabel)   
  xAxis.setAutoRangeIncludesZero(False)   
  yAxis = NumberAxis(ylabel)   
  yAxis.setAutoRangeIncludesZero(False)   
   
  series = XYSeries("Values");     
  for (i,j) in data:         
    series.add(i, j)

  dataset = XYSeriesCollection()
  dataset.addSeries(series);
  chart = ChartFactory.createScatterPlot(name, xlabel, ylabel, dataset, 
    PlotOrientation.VERTICAL, True, True, False)    
  plot = chart.getPlot()
  plot.getRenderer().setSeriesShape(0, 
    ShapeUtilities.createRegularCross(size,size));                  
    
  return Chart(chart)
    
示例#3
0
 def createChart(self):
     dataset = XYSeriesCollection()
     for s in self.allSeries:
         dataset.addSeries(s)
     # title is None
     chart = ChartFactory.createScatterPlot( \
                 None, xlabel(), ylabel(), \
                 dataset, PlotOrientation.VERTICAL, \
                 True, True, False)
     return chart
示例#4
0
 def createChart(self):
     dataset = XYSeriesCollection()
     for s in self.allSeries:
         dataset.addSeries(s)
     # title is None
     chart = ChartFactory.createScatterPlot( \
                 None, xlabel(), ylabel(), \
                 dataset, PlotOrientation.VERTICAL, \
                 True, True, False)
     return chart
def plot2D(points, Ca, Cb):
	maxIntensity = 255.0
	dataset = XYSeriesCollection()

	seriesNN = XYSeries(channels[Ca+1]+" -ve "+channels[Cb+1]+" -ve")
	seriesPP = XYSeries(channels[Ca+1]+" +ve "+channels[Cb+1]+" +ve")
	seriesNP = XYSeries(channels[Ca+1]+" -ve "+channels[Cb+1]+" +ve")
	seriesPN = XYSeries(channels[Ca+1]+" +ve "+channels[Cb+1]+" -ve")
	for p in points:
		posA = channels[Ca+1] in thresholds and p[Ca]>thresholds[ channels[Ca+1] ]
		posB = channels[Cb+1] in thresholds and p[Cb]>thresholds[ channels[Cb+1] ]
		if posA and posB:
			seriesPP.add(p[Cb], p[Ca])
		elif posA:
			seriesPN.add(p[Cb], p[Ca])
		elif posB:
			seriesNP.add(p[Cb], p[Ca])
		else:
			seriesNN.add(p[Cb], p[Ca])
	dataset.addSeries(seriesNN)
	dataset.addSeries(seriesPN)
	dataset.addSeries(seriesNP)
	dataset.addSeries(seriesPP)
	
	chart = ChartFactory.createScatterPlot( title+" - "+channels[Cb+1]+" vs "+channels[Ca+1], channels[Cb+1], channels[Ca+1], dataset, PlotOrientation.VERTICAL, False,True,False )
	plot = chart.getPlot()
	plot.getDomainAxis().setRange(Range(0.00, maxIntensity), True, False)
	plot.getRangeAxis().setRange(Range(0.00, maxIntensity), True, False)
	renderer = chart.getPlot().getRenderer()
	
	renderer.setSeriesPaint(0, Color(64,64,64)) #NN
	renderer.setSeriesPaint(1, Color(0,255,0)) #PN
	renderer.setSeriesPaint(2, Color(0,0,255)) #NP
	renderer.setSeriesPaint(3, Color(0,255,255)) #PP

	shape = Ellipse2D.Float(-1,-1,3,3)
	renderer.setSeriesShape(0, shape )
	renderer.setSeriesShape(1, shape )
	renderer.setSeriesShape(2, shape )
	renderer.setSeriesShape(3, shape )
	
	frame = ChartFrame(title+" - "+channels[Cb+1]+" vs "+channels[Ca+1], chart)
	frame.setSize(800, 800)
	frame.setLocationRelativeTo(None)
	frame.setVisible(True)
示例#6
0
def measure(stack, cells, nuclei):
    time = [ (t-1)*cal.frameInterval for t in range(T+1) ]
    cellValues0 = [ 0.0 for t in range(T+1) ]
    cellValues1 = [ 0.0 for t in range(T+1) ]
    cellAreas0 = [ 0.0 for t in range(T+1) ]
    cellAreas1 = [ 0.0 for t in range(T+1) ]
    nucleusValues0 = [ 0.0 for t in range(T+1) ]
    nucleusValues1 = [ 0.0 for t in range(T+1) ]
    nucleusAreas0 = [ 0.0 for t in range(T+1) ]
    nucleusAreas1 = [ 0.0 for t in range(T+1) ]
    nonNucleusValues0 = [ 0.0 for t in range(T+1) ]
    nonNucleusValues1 = [ 0.0 for t in range(T+1) ]

    for t in range(1,T+1):
        ip = stack.getProcessor(t)

        if cells[t] is None:
            continue


        #subtract background Z from all intensity Z measurements
        if cells [t] is None:
            print("Nocellsfound" + str(t))
        bothCells = ShapeRoi(cells[t][0]).or(ShapeRoi(cells[t][1]))
        backRoi = ShapeRoi(Rectangle(0,0,imp.getWidth(),imp.getHeight())).not( bothCells )


        ip.setRoi(backRoi)
        backMean = ip.getStatistics().mean

        ip.setRoi( cells[t][0] )
        stats0 = ip.getStatistics()
        cellValues0[t] = stats0.mean - backMean
        cellAreas0[t] = stats0.area * cal.pixelWidth * cal.pixelHeight
        nuc0 = None
        for nuc in nuclei[t]:
            rect = nuc.getBounds()
            nx = int(rect.x+(rect.width/2.0))
            ny = int(rect.y+(rect.height/2.0))
            if cells[t][0].contains(nx,ny):
                nuc0 = nuc
                break
        if nuc0 is not None:
            ip.setRoi( nuc0 )
            nucStats0 = ip.getStatistics()
            nucleusValues0[t] = nucStats0.mean - backMean
            nucleusAreas0[t] = nucStats0.area * cal.pixelWidth * cal.pixelHeight
            nuc0.setPosition(0,0,t)
            nuc0.setStrokeColor(Color.CYAN)
            ol.add(nuc0)
            nonnucRoi0 = ShapeRoi(cells[t][0]).not( ShapeRoi(nuc0) )
            ip.setRoi( nonnucRoi0 )
            nonNucleusValues0[t] = ip.getStatistics().mean - backMean

        ip.setRoi( cells[t][1] )
        stats1 = ip.getStatistics()
        cellValues1[t] = stats1.mean - backMean
        cellAreas1[t] = stats1.area * cal.pixelWidth * cal.pixelHeight
        nuc1 = None
        for nuc in nuclei[t]:
            rect = nuc.getBounds()
            nx = int(rect.x+(rect.width/2.0))
            ny = int(rect.y+(rect.height/2.0))
            if cells[t][1].contains(nx,ny):
                nuc1 = nuc
                break
        if nuc1 is not None:
            ip.setRoi( nuc1 )
            nucStats1 = ip.getStatistics()
            nucleusValues1[t] = nucStats1.mean - backMean
            nucleusAreas1[t] = nucStats1.area * cal.pixelWidth * cal.pixelHeight
            nuc1.setPosition(0,0,t)
            nuc1.setStrokeColor(Color.CYAN)
            ol.add(nuc1)
            nonnucRoi1 = ShapeRoi(cells[t][1]).not( ShapeRoi(nuc1) )
            ip.setRoi( nonnucRoi1 )
            nonNucleusValues1[t] = ip.getStatistics().mean - backMean

    rt = ResultsTable()
    rt.showRowNumbers(False)
    for t in range(1,T+1):
        rt.setValue("Time ("+cal.getTimeUnit()+")", t-1, IJ.d2s(time[t],1))
        areaRatio = cellAreas0[t] / cellAreas1[t] if cellAreas0[t]>0 and cellAreas1[t]>0 else 0.0
        rt.setValue("Cell 0:Cell 1 Area Ratio", t-1, areaRatio)

        nucleusRatio = nucleusValues0[t] / nucleusValues1[t] if nucleusValues0[t]>0 and nucleusValues1[t]>0 else 0.0
        rt.setValue("Cell 0:Cell 1 Nucleus Ratio", t-1, nucleusRatio)
        nonNucleusRatio = nonNucleusValues0[t] / nonNucleusValues1[t] if nonNucleusValues0[t]>0 and nonNucleusValues1[t]>0 else 0.0
        rt.setValue("Cell 0:Cell 1 Non-Nucleus Ratio", t-1, nonNucleusRatio)

        nnnRatio0 = nucleusValues0[t] / nonNucleusValues0[t] if nucleusValues0[t]>0 and nonNucleusValues0[t]>0 else 0.0
        rt.setValue("Cell 0 Nucleus:Non-Nucleus Ratio", t-1, nnnRatio0)
        nnnRatio1 = nucleusValues1[t] / nonNucleusValues1[t] if nucleusValues1[t]>0 and nonNucleusValues1[t]>0 else 0.0
        rt.setValue("Cell 1 Nucleus:Non-Nucleus Ratio", t-1, nnnRatio1)

        rt.setValue("Cell 0 (red) Area ("+cal.getUnit()+u"\u00b2"+")", t-1, cellAreas0[t])
        rt.setValue("Cell 0 Nucleus Area ("+cal.getUnit()+u"\u00b2"+")", t-1, nucleusAreas0[t])
        rt.setValue("Cell 0 All", t-1, cellValues0[t])
        rt.setValue("Cell 0 Nucleus", t-1, nucleusValues0[t])
        rt.setValue("Cell 0 Non-Nucleus", t-1, nonNucleusValues0[t])
        rt.setValue("Cell 1 (green) Area ("+cal.getUnit()+u"\u00b2"+")", t-1, cellAreas1[t])
        rt.setValue("Cell 1 Nucleus Area ("+cal.getUnit()+u"\u00b2"+")", t-1, nucleusAreas1[t])
        rt.setValue("Cell 1 All", t-1, cellValues1[t])
        rt.setValue("Cell 1 Nucleus", t-1, nucleusValues1[t])
        rt.setValue("Cell 1 Non-Nucleus", t-1, nonNucleusValues1[t])
    rt.show(imp.getTitle()+"-Results")

    dataset = DefaultXYDataset()
    dataset.addSeries( "Cell 0", [time[1:], cellValues0[1:]] )
    dataset.addSeries( "Cell 1", [time[1:], cellValues1[1:]] )
    dataset.addSeries( "Nucleus 0", [time[1:], nucleusValues0[1:]] )
    dataset.addSeries( "Nucleus 1", [time[1:], nucleusValues1[1:]] )
    dataset.addSeries( "Non-Nucleus 0", [time[1:], nonNucleusValues0[1:]] )
    dataset.addSeries( "Non-Nucleus 1", [time[1:], nonNucleusValues1[1:]] )

    chart = ChartFactory.createScatterPlot( imp.getTitle(), "Time ("+cal.getTimeUnit()+")", "Intensity Z", dataset, PlotOrientation.VERTICAL, True,True,False )
    plot = chart.getPlot()

    plot.setBackgroundPaint(Color(64, 128, 255))
    plot.setDomainGridlinePaint(Color.BLACK)
    plot.setRangeGridlinePaint(Color.BLACK)

    renderer = plot.getRenderer()
    legend = LegendItemCollection()
    shapeR = 2.0
    nucShape = Ellipse2D.Float(-shapeR,-shapeR,shapeR*2,shapeR*2)
    nonNucShape = Path2D.Float()
    nonNucShape.moveTo(-shapeR,-shapeR)
    nonNucShape.lineTo(shapeR,shapeR)
    nonNucShape.moveTo(shapeR,-shapeR)
    nonNucShape.lineTo(-shapeR,shapeR)
    for s in range(dataset.getSeriesCount()):

        if s == 0:
            renderer.setSeriesLinesVisible(s, True)
            renderer.setSeriesShapesVisible(s, False)
            renderer.setSeriesStroke(s, BasicStroke(1))
            renderer.setSeriesPaint(s, Color.RED)
            legend.add( LegendItem("Cell 0", Color.RED) )
        elif s == 1:
            renderer.setSeriesLinesVisible(s, True)
            renderer.setSeriesShapesVisible(s, False)
            renderer.setSeriesStroke(s, BasicStroke(1))
            renderer.setSeriesPaint(s, Color.GREEN)
            legend.add( LegendItem("Cell 1", Color.GREEN) )
        elif s == 2:
            renderer.setSeriesLinesVisible(s, False)
            renderer.setSeriesShapesVisible(s, True)
            renderer.setSeriesShape(s, nucShape)
            renderer.setSeriesPaint(s, Color.RED)
        elif s == 3:
            renderer.setSeriesLinesVisible(s, False)
            renderer.setSeriesShapesVisible(s, True)
            renderer.setSeriesShape(s, nucShape)
            renderer.setSeriesPaint(s, Color.GREEN)
        elif s == 4:
            renderer.setSeriesLinesVisible(s, False)
            renderer.setSeriesShapesVisible(s, True)
            renderer.setSeriesShape(s, nonNucShape)
            renderer.setSeriesPaint(s, Color.RED)
        elif s == 5:
            renderer.setSeriesLinesVisible(s, False)
            renderer.setSeriesShapesVisible(s, True)
            renderer.setSeriesShape(s, nonNucShape)
            renderer.setSeriesPaint(s, Color.GREEN)


    plot.setFixedLegendItems(legend)

    frame = ChartFrame(imp.getTitle()+" Z-Normalised Intensity", chart)
    frame.pack()
    frame.setSize( Dimension(800, 800) )
    frame.setLocationRelativeTo(None)
    frame.setVisible(True)
示例#7
0
def scatter(data,x=None,y=None,**kwargs):
    ''' Creates a scatter plot comparing two elements. At minimum, takes a collection of data.
        The second and third arguments, if they exist, are treated as the two elements to 
        compare. If these arguments do not exist, the first two elements in the list are 
        compared. If an optional regress=True argument is present, superimposes a linear 
        regression for each series and prints some related info (R-value etc). 
        Note that scatter plots can be zoomed with the mouse. Returns the plot object in
        case you want to customize the graph in some way. Takes an optional showMissing argument 
        which determines whether missing values (-9999.0) should be displayed. 
        Examples: scatter(data), scatter(data,"tmin","tmax",regress=True)
    '''
    from org.jfree.data.xy import XYSeriesCollection,XYSeries
    from org.jfree.data import UnknownKeyException
    from org.jfree.chart import ChartFactory,ChartFrame
    from org.jfree.chart.plot import PlotOrientation,DatasetRenderingOrder
    from org.jfree.chart.renderer.xy import XYLineAndShapeRenderer
    from java.awt import Color
    
    regress=kwargs.get('regress',False)
    showMissing=kwargs.get('showMissing',False)
    
    # Try to be flexible about element parameters
    if x is not None: x = findElement(x).name
    if y is not None: y = findElement(y).name

    # Create a dataset from the data
    collection = XYSeriesCollection()
    for ob in data.groupedByObservation().items():
        key,values = ob
        name = str(key[0])
        if x==None:
            x = values[0].element.name
        try:
            xFact = (i for i in values if i.element.name == x).next()
        except StopIteration: # missing value
            continue
        xval  = xFact.value
        if xval in missingValues and not showMissing: continue  
        if y==None:
            try:
                y = values[1].element.name
            except IndexError:
                raise Exception("Error! Your data request returned only 1 value per observation. " 
                                "Must have 2 values to generate a scatter plot.")
        try:
            yFact = (i for i in values if i.element.name == y).next()
        except StopIteration: # missing value
            continue
        yval  = yFact.value
        if yval in missingValues and not showMissing: continue  
        
        try: 
            series = collection.getSeries(name)
        except UnknownKeyException:
            collection.addSeries(XYSeries(name))
            series = collection.getSeries(name)
        
        series.add(float(xval),float(yval))

    # Create chart from dataset        
    chart = ChartFactory.createScatterPlot( "", x, y, collection, PlotOrientation.VERTICAL,
                                            True, True, False );
    plot = chart.getPlot()
    frame = ChartFrame("Scatter Plot", chart);
    frame.pack();
    frame.setVisible(True);

    # Superimpose regression if desired
    if regress:
        regressioncollection = XYSeriesCollection()
        for series in collection.getSeries():
            regression = _getregression(series)
            x1 = series.getMinX()
            y1 = regression.predict(x1)
            x2 = series.getMaxX()
            y2 = regression.predict(x2)
            regressionseries = XYSeries(series.getKey())
            regressionseries.add(float(x1),float(y1))
            regressionseries.add(float(x2),float(y2))
            regressioncollection.addSeries(regressionseries)

            print series.getKey(),":"
            print "  R:            %8.4f" % regression.getR()
            print "  R-squared:    %8.4f" % regression.getRSquare()
            print "  Significance: %8.4f" % regression.getSignificance()
            print
            
        plot.setDataset(1,regressioncollection)
        regressionRenderer = XYLineAndShapeRenderer(True,False)
        plot.setRenderer(1,regressionRenderer)
        plot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
        
        colors = [0xec0000,0x58b911,0x6886ea,0xedd612,0xa93bb9,0xffb71b,0xe200df,0x1de2b6,0xdc91db,0x383838,0xb09344,0x4ea958,0xd78c9e,0x64008d,0xb0c95b]
        mainRenderer = plot.getRenderer(0)
        for i in range(collection.getSeriesCount()):
            try:
                mainRenderer.setSeriesPaint(i,Color(colors[i]))
                regressionRenderer.setSeriesPaint(i,Color(colors[i]))
            except IndexError: # Finite # of colors in the color array; beyond that let jfreechart pick
                break
        '''
        # Jump through some hoops to ensure regressions are same color as scatters for each series.
        # Initially: doesn't work because series are not indexed the same. And I don't see a way
        # to get the actual series from the renderer in order to compare names or something.
        mainRenderer = plot.getRenderer(0)
        print "Renderer is",type(mainRenderer)
        index = 0
        paint = mainRenderer.lookupSeriesPaint(index)
        print "Paint is",type(paint)
        while (paint is not None):
            print "Setting paint."
            regressionRenderer.setSeriesPaint(index,paint)
            index += 1
            paint = mainRenderer.getSeriesPaint(index)
        '''
        return plot
示例#8
0
#imgB = WindowManager.getImage("26.93/25.90:test_file")

imgA = WindowManager.getImage("12.12:test_file")
imgB = WindowManager.getImage("13.01/12.12:test_file")


ui = UI.getInstance()
rois = ui.getRoiManager().getAllROIs()

print "Create empty dataset"
dataset = DefaultXYDataset()

print "Create ScatterPlot"

chart = ChartFactory.createScatterPlot(
	"Scatter Plot", imgA.getTitle(), imgB.getTitle(),
	dataset, PlotOrientation.VERTICAL,
	True, False, False);

# random test data
#
#print "Add series to dataset"
#npoints = 1000
#data = [[],[]]
#for i in range(npoints):
#	data[0].append(i)
#	data[1].append(2*i+random.gauss(0,50))
#
# this trick is needed to go from a 2D python array 
# to a 2D java array of doubles, see:
# http://fiji.sc/wiki/index.php/Jython_Scripting#Creating_multi-dimensional_native_java_arrays
#twoDimArr = array(data, Class.forName('[D'))