502 lines
16 KiB
Java
502 lines
16 KiB
Java
/*
|
|
* Copyright (c) 2014 Paul Scherrer Institute. All rights reserved.
|
|
*/
|
|
package ch.psi.mxsc;
|
|
|
|
import ch.psi.pshell.device.Device;
|
|
import ch.psi.pshell.device.DeviceBase;
|
|
import ch.psi.pshell.imaging.DimensionDouble;
|
|
import ch.psi.pshell.imaging.PointDouble;
|
|
import ch.psi.utils.swing.MainFrame;
|
|
import ch.psi.utils.swing.SwingUtils;
|
|
import java.awt.BasicStroke;
|
|
import java.awt.Color;
|
|
import java.awt.Dimension;
|
|
import java.awt.Font;
|
|
import java.awt.Graphics;
|
|
import java.awt.Graphics2D;
|
|
import java.awt.Point;
|
|
import java.awt.Rectangle;
|
|
import java.util.ArrayList;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public class Puck extends DeviceBase {
|
|
|
|
final static PointDouble[] samplesPosition = new PointDouble[]{
|
|
new PointDouble(0, 24.24),
|
|
new PointDouble(23.05360995, 7.490571944),
|
|
new PointDouble(14.24791452, -19.61057194),
|
|
new PointDouble(-14.24791452, -19.61057194),
|
|
new PointDouble(-23.05360995, 7.490571944),
|
|
new PointDouble(0, 52.52),
|
|
new PointDouble(28.39445573, 44.18263554),
|
|
new PointDouble(47.7738724, 21.81759648),
|
|
new PointDouble(51.98542213, -7.474375306),
|
|
new PointDouble(39.69196765, -34.39328575),
|
|
new PointDouble(14.79659389, -50.39257097),
|
|
new PointDouble(-14.79659389, -50.39257097),
|
|
new PointDouble(-39.69196765, -34.39328575),
|
|
new PointDouble(-51.98542213, -7.474375306),
|
|
new PointDouble(-47.7738724, 21.81759648),
|
|
new PointDouble(-28.39445573, 44.18263554)
|
|
};
|
|
|
|
static final Character[] SEGMENTS = new Character[]{'A', 'A',
|
|
'F', 'F', 'F', 'F', 'F',
|
|
'E', 'E', 'E', 'E', 'E',
|
|
'D', 'D', 'D', 'D', 'D',
|
|
'C', 'C', 'C', 'C', 'C',
|
|
'B', 'B', 'B', 'B', 'B',
|
|
'A', 'A', 'A'};
|
|
static final int[] NUMBERS = new int[]{1, 2,
|
|
5, 4, 3, 1, 2,
|
|
5, 4, 3, 1, 2,
|
|
5, 4, 3, 1, 2,
|
|
5, 4, 3, 1, 2,
|
|
5, 4, 3, 1, 2,
|
|
5, 4, 3};
|
|
static final int[] ADDRESSES = new int[]{6, 7,
|
|
5, 4, 3, 1, 2,
|
|
20, 19, 18, 16, 17,
|
|
15, 14, 13, 11, 12,
|
|
30, 29, 28, 26, 27,
|
|
25, 24, 23, 21, 22,
|
|
10, 9, 8};
|
|
|
|
static final double[] ANGLES = new double[]{
|
|
0.00, 0.00, 19.11, 40.89, 30.00,
|
|
60.00, 60.00, 79.11, 100.89, 90.00,
|
|
120.00, 120.00, 139.11, 160.89, 150.00,
|
|
180.00, 180.00, 199.11, 220.89, 210.00,
|
|
240.00, 240.00, 259.11, 280.89, 270.00,
|
|
300.00, 300.00, 319.11, 340.89, 330.00};
|
|
|
|
final static PointDouble referencePosition = new PointDouble(0.0, -66.9 - 0.2);
|
|
final static Double referenceSize = 6.2 + 0.2;
|
|
final static PointDouble ledUnipuckPosition = new PointDouble(0.0, 0.0);
|
|
final static PointDouble ledMinispinePosition = new PointDouble(0.0, -36.0);
|
|
final static Double unipuckLedSize = 10.0;
|
|
final static Double minispineLedSize = 8.0;
|
|
final static PointDouble labelPositionWithImage = new PointDouble(0.0, 36.0);
|
|
|
|
|
|
PuckType puckType = PuckType.Unknown;
|
|
|
|
public PuckType getPuckType(){
|
|
return puckType;
|
|
}
|
|
|
|
public void setPuckType(PuckType value){
|
|
puckType = value;
|
|
}
|
|
|
|
public enum PuckType{
|
|
Empty,
|
|
Minispine,
|
|
Unipuck,
|
|
Error,
|
|
Unknown;
|
|
|
|
public boolean isDefined(){
|
|
return (this==Minispine) || (this==Unipuck);
|
|
}
|
|
|
|
}
|
|
|
|
public String getStatus(){
|
|
if ((detection==Detection.Present) && puckType.isDefined()) {
|
|
return puckType.toString();
|
|
}
|
|
return detection.toString();
|
|
}
|
|
|
|
public double getAngle() {
|
|
return ANGLES[index];
|
|
}
|
|
|
|
final int numberOfSamples = samplesPosition.length;
|
|
|
|
final int index;
|
|
|
|
Character segment;
|
|
final int address;
|
|
final int number;
|
|
final double angle;
|
|
|
|
Puck(BasePlate basePlate, int index) {
|
|
//super(String.valueOf(index+1));
|
|
super(SEGMENTS[index] + "" + NUMBERS[index]);
|
|
this.setParent(basePlate);
|
|
this.index = index;
|
|
this.segment = SEGMENTS[index];
|
|
this.number = NUMBERS[index];
|
|
this.address = ADDRESSES[index];
|
|
this.angle = getAngle();
|
|
for (int i = 0; i < numberOfSamples; i++) {
|
|
new Sample(this, i);
|
|
}
|
|
}
|
|
|
|
public BasePlate getBasePlate() {
|
|
return (BasePlate) getParent();
|
|
}
|
|
|
|
DimensionDouble getSize() {
|
|
return new DimensionDouble(67.0, 67.0);
|
|
}
|
|
|
|
public Sample[] getSamples() {
|
|
ArrayList<Sample> ret = new ArrayList<>();
|
|
for (Device d : getChildren()) {
|
|
ret.add((Sample) d);
|
|
}
|
|
return ret.toArray(new Sample[0]);
|
|
}
|
|
|
|
public PointDouble getRotatedPosition(PointDouble ref) {
|
|
double rotation = - angle * Math.PI / 180.0;
|
|
double x = ref.x * Math.cos(rotation) - ref.y * Math.sin(rotation);
|
|
double y = ref.y * Math.cos(rotation) + ref.x * Math.sin(rotation);
|
|
return new PointDouble(x,y );
|
|
}
|
|
|
|
public PointDouble getSamplePosition(Sample sample) {
|
|
//PointDouble ref = samplesPosition[sample.index];
|
|
//return getRotatedPosition(ref);
|
|
return samplesPosition[sample.index];
|
|
}
|
|
|
|
public Point getDrawUnipuckLedPosition(){
|
|
PointDouble ref = ledUnipuckPosition;
|
|
return getDrawPosition(ref);
|
|
}
|
|
|
|
public Point getDrawMinispineLedPosition(){
|
|
PointDouble ref = ledMinispinePosition;
|
|
return getDrawPosition(ref);
|
|
}
|
|
|
|
|
|
int getUnipuckLedSize() {
|
|
return getDrawSize(unipuckLedSize) ;
|
|
}
|
|
|
|
int getMinispineLedSize() {
|
|
return getDrawSize(minispineLedSize) ;
|
|
}
|
|
|
|
int getDrawSize(double refSize) {
|
|
return (int) ((refSize / getSize().getWidth()) * getDrawSize()) ;
|
|
}
|
|
|
|
Point getDrawPosition(PointDouble refPosition) {
|
|
Point puckCenter = getDrawPosition();
|
|
int puckDrawSize = getDrawSize();
|
|
DimensionDouble puckSize = getSize();
|
|
PointDouble pos = getRotatedPosition(refPosition);
|
|
return new Point( (int) ((pos.x / puckSize.getWidth())* puckDrawSize/2 + puckCenter.x) ,
|
|
(int) ((pos.y / puckSize.getHeight())* puckDrawSize/2 + puckCenter.y) );
|
|
}
|
|
|
|
|
|
public boolean isSegmentSelected() {
|
|
/*
|
|
switch(Integer.valueOf(Controller.getInstance().getHexaposiPosition())){
|
|
case 1: return getSegment()=='A';
|
|
case 2: return getSegment()=='B';
|
|
case 3: return getSegment()=='C';
|
|
case 4: return getSegment()=='D';
|
|
case 5: return getSegment()=='E';
|
|
case 6: return getSegment()=='F';
|
|
}
|
|
} catch(Exception ex){
|
|
}
|
|
return false;
|
|
*/
|
|
return ("" + getSegment()).equalsIgnoreCase(Controller.getInstance().getHexiposiPosition());
|
|
}
|
|
|
|
public boolean isHighlithted() {
|
|
return isSelected() || isSegmentSelected();
|
|
}
|
|
|
|
public int getIndex() {
|
|
return index;
|
|
}
|
|
String id;
|
|
|
|
public String getId() {
|
|
//return "XXX000" + index;
|
|
return id;
|
|
}
|
|
|
|
public void setId(String value) {
|
|
id = value;
|
|
}
|
|
|
|
public char getSegment() {
|
|
return segment;
|
|
}
|
|
|
|
public int getNumber() {
|
|
return number;
|
|
}
|
|
|
|
public int getAddress() {
|
|
return address;
|
|
}
|
|
|
|
boolean enabled;
|
|
|
|
public boolean isEnabled() {
|
|
return enabled;
|
|
}
|
|
|
|
public void setEnabled(boolean value) {
|
|
enabled = value;
|
|
}
|
|
|
|
public enum Detection {
|
|
Empty,
|
|
Present,
|
|
Offline,
|
|
Error
|
|
}
|
|
|
|
Detection detection = Detection.Error;
|
|
|
|
public Detection getDetection() {
|
|
return detection;
|
|
}
|
|
|
|
boolean detectionError;
|
|
|
|
public boolean isDetectionError() {
|
|
return detectionError;
|
|
}
|
|
|
|
private boolean selected;
|
|
|
|
public boolean isSelected() {
|
|
return selected && getBasePlate().isSelectable();
|
|
}
|
|
|
|
public void toggleSelected(boolean value) {
|
|
setSelected(!selected);
|
|
}
|
|
|
|
public void setSelected(boolean value) {
|
|
if (value != selected) {
|
|
if (value == true) {
|
|
for (Device d : getParent().getChildren()) {
|
|
if (d instanceof Puck) {
|
|
((Puck) d).selected = false;
|
|
for (Sample sample : ((Puck) d).getSamples()) {
|
|
sample.selected = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (Sample sample : getSamples()) {
|
|
sample.selected = false;
|
|
}
|
|
selected = value;
|
|
getBasePlate().onSelectionChanged();
|
|
}
|
|
}
|
|
|
|
public int getNumberOfSamples() {
|
|
return numberOfSamples;
|
|
}
|
|
|
|
Color getColor() {
|
|
Color ret = Color.LIGHT_GRAY;
|
|
switch (detection) {
|
|
case Empty:
|
|
//ret = isHighlithted() ? new Color(224, 224, 224) : Color.LIGHT_GRAY;
|
|
ret = isHighlithted() ? new Color(212, 212, 212) : Color.LIGHT_GRAY;
|
|
break;
|
|
case Present:
|
|
if ((puckType != null) && (puckType != PuckType.Unknown)){
|
|
switch (puckType){
|
|
case Minispine:
|
|
ret = isHighlithted() ? new Color(0, 200, 80) : new Color(128, 232, 152);
|
|
break;
|
|
case Unipuck:
|
|
ret = isHighlithted() ? new Color(0, 140, 140) : new Color(128, 192, 192);
|
|
break;
|
|
case Empty:
|
|
case Error:
|
|
ret = isHighlithted() ? new Color(192, 10, 10) : new Color(192, 128, 128);
|
|
break;
|
|
}
|
|
} else {
|
|
ret = isHighlithted() ? new Color(0, 140, 140) : new Color(128, 192, 192);
|
|
}
|
|
break;
|
|
case Error:
|
|
ret = isHighlithted() ? new Color(192, 10, 10) : new Color(192, 128, 128);
|
|
break;
|
|
case Offline:
|
|
ret = isHighlithted() ? new Color(250, 255, 48) : new Color(253, 194, 41);
|
|
//ret = isHighlithted() ? new Color(230, 142, 40) : new Color(216, 159, 93);
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int getDrawSize() {
|
|
//Single puck plot
|
|
if (plotRect != null) {
|
|
return Math.min(plotRect.width, plotRect.height);
|
|
}
|
|
//All pucks
|
|
Rectangle plotRect = getBasePlate().getBoundingBox();
|
|
int ret = Math.min(
|
|
(int) ((getSize().getWidth() / getBasePlate().getSize().getWidth()) * plotRect.width),
|
|
(int) ((getSize().getHeight() / getBasePlate().getSize().getHeight()) * plotRect.height)
|
|
);
|
|
if (isSelected()) {
|
|
ret += 2;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
Point getDrawPosition() {
|
|
//Single puck plot
|
|
if (plotRect != null) {
|
|
return new Point((int) plotRect.getCenterX(), (int) plotRect.getCenterY());
|
|
}
|
|
//All pucks
|
|
Rectangle plotRect = getBasePlate().getBoundingBox();
|
|
DimensionDouble plateSize = getBasePlate().getSize();
|
|
PointDouble pos = getBasePlate().getPuckPosition(this);
|
|
return new Point((int) ((pos.x / plateSize.getWidth()) * plotRect.width + plotRect.getCenterX()),
|
|
(int) ((pos.y / plateSize.getHeight()) * plotRect.height + plotRect.getCenterY())
|
|
);
|
|
}
|
|
|
|
Color getLabelColor(boolean drawBackground) {
|
|
return drawBackground ? (isHighlithted() ? Color.BLACK : new Color(92, 92, 92)) : (isHighlithted() ? new Color(0, 255, 0) : new Color(0, 162, 0));
|
|
|
|
}
|
|
|
|
Font getLabelFont() {
|
|
/*
|
|
if (plotRect != null) {
|
|
return new Font("Times New Roman", Font.BOLD, 18);
|
|
}
|
|
return new Font("Times New Roman", Font.BOLD, 10);
|
|
*/
|
|
if (plotRect != null) {
|
|
return new Font("Segoe UI", Font.BOLD, 18);
|
|
}
|
|
return new Font("Segoe UI", Font.BOLD, 12);
|
|
}
|
|
|
|
Font getIdFont() {
|
|
if (plotRect != null) {
|
|
return new Font("Times New Roman", Font.PLAIN, 12);
|
|
}
|
|
return new Font("Times New Roman", Font.PLAIN, 9);
|
|
}
|
|
|
|
Point getLabelDrawPosition(String text, Graphics g, boolean drawBackground) {
|
|
Point pos = drawBackground ? getDrawPosition() : getDrawPosition(labelPositionWithImage);
|
|
Dimension textSize = SwingUtils.getTextSize(text, g.getFontMetrics());
|
|
return new Point(pos.x - textSize.width / 2 , pos.y + (g.getFontMetrics().getAscent() / 2));
|
|
}
|
|
|
|
Color getBorderColor(boolean drawBackground) {
|
|
if (drawBackground) {
|
|
/*if (!isEnabled()){
|
|
return Color.GRAY;
|
|
} else */
|
|
if (isHighlithted()) {
|
|
return new Color(0, 0, 0);
|
|
}
|
|
return Color.GRAY;
|
|
}
|
|
return isHighlithted() ? new Color(0, 208, 0) : new Color(0, 128, 0);
|
|
}
|
|
|
|
int getBorderWidth(boolean drawBackground) {
|
|
return drawBackground ? isSegmentSelected() ? 2 : 1 : isSegmentSelected() ? 2 : 1;
|
|
}
|
|
|
|
int getReferenceDrawSize() {
|
|
return getDrawSize(referenceSize) ;
|
|
}
|
|
|
|
Point getReferenceDrawPosition() {
|
|
return getDrawPosition(new PointDouble(0, -67.0));
|
|
|
|
}
|
|
|
|
Rectangle plotRect;
|
|
|
|
void draw(Graphics2D g, Rectangle plotRect, boolean drawSamples, boolean drawId, boolean drawBackground, BasePlate enclosingPlate) {
|
|
this.plotRect = plotRect;
|
|
Point position = getDrawPosition();
|
|
int size = getDrawSize();
|
|
if (drawBackground) {
|
|
g.setColor(getColor());
|
|
g.fillOval(position.x - size / 2, position.y - size / 2, size, size);
|
|
}
|
|
g.setColor(getBorderColor(drawBackground));
|
|
g.setStroke(new BasicStroke(getBorderWidth(drawBackground)));
|
|
g.drawOval(position.x - size / 2, position.y - size / 2, size, size);
|
|
g.setStroke(new BasicStroke(1f));
|
|
if (drawSamples) {
|
|
//Draw samples
|
|
for (Sample sample : getSamples()) {
|
|
sample.draw(g, drawBackground);
|
|
}
|
|
}
|
|
|
|
//Draw reference
|
|
Color refColor = MainFrame.isDark() ? Color.DARK_GRAY : new Color(214, 217, 223);
|
|
if ((enclosingPlate != null) && enclosingPlate.drawContour) {
|
|
refColor = enclosingPlate.getColor();
|
|
}
|
|
|
|
if (drawBackground){
|
|
g.setColor(refColor);
|
|
position = getReferenceDrawPosition();
|
|
size = getReferenceDrawSize();
|
|
//size+=1;
|
|
g.fillArc(position.x - size / 2, position.y - size / 2 , size, size, (int) (180 + angle), 180);
|
|
g.setColor(getBorderColor(drawBackground));
|
|
g.drawArc(position.x - size / 2, position.y - size / 2 , size, size, (int) (180 + angle), 180);
|
|
} else {
|
|
Point pu = getDrawUnipuckLedPosition();
|
|
Point pm = getDrawMinispineLedPosition();
|
|
int unipuckSize = getUnipuckLedSize();
|
|
int minispineSize = getMinispineLedSize();
|
|
g.setColor(getBorderColor(drawBackground));
|
|
g.drawOval(pu.x - unipuckSize / 2, pu.y - unipuckSize / 2, unipuckSize, unipuckSize);
|
|
g.drawOval(pm.x - minispineSize / 2, pm.y - minispineSize / 2, minispineSize, minispineSize);
|
|
}
|
|
|
|
//Draw text
|
|
String text = getName(); //String.valueOf(getIndex() + 1);
|
|
g.setColor(getLabelColor(drawBackground));
|
|
g.setFont(getLabelFont());
|
|
Point labelPosition = getLabelDrawPosition(text, g, drawBackground);
|
|
g.drawString(text, labelPosition.x, labelPosition.y);
|
|
if (drawId) {
|
|
String id = getId();
|
|
if (id != null) {
|
|
labelPosition.setLocation(labelPosition.x, labelPosition.y - 6);
|
|
g.setFont(getIdFont());
|
|
Dimension textSize = SwingUtils.getTextSize(id, g.getFontMetrics());
|
|
g.drawString(id, getDrawPosition().x - textSize.width/2 , getDrawPosition().y + 10 );
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|