我目前正在尝试使用csv格式的平面描述文件构建Java中的bean类列表。具体来说：
这是csv文件的结构：
MES_ID;GRP_PARENT_ID;GRP_ID;ATTR_ID
M1 ; ;G1 ;A1
M1 ; ;G1 ;A2
M1 ;G1 ;G2 ;A3
M1 ;G1 ;G2 ;A4
M1 ;G2 ;G3 ;A5
M1 ; ;G4 ;A6
M1 ; ;G4 ;A7
M1 ; ;G4 ;A8
M2 ; ;G1 ;A1
M2 ; ;G1 ;A2
M2 ; ;G2 ;A3
M2 ; ;G2 ;A4
它对应于分层数据结构：
M1
---G1
------A1
------A2
------G2
---------A3
---------A4
---------G3
------------A5
---G4
------A7
------A8
M2
---G1
------A1
------A2
---G2
------A3
------A4
备注：
消息M可以包含无限数量的组G和属性A
G组可以拥有无限数量的属性和无限数量的小组，每个小组都有不足组
那个说法，我正在尝试阅读这个平面的csv decription，将它存储在这个bean的结构中：
Map<String, MBean> messages = new HashMap<String, Mbean>();
==
public class MBean {
private String mes_id;
private Map<String, GBean> groups;
}
public class GBean {
private String grp_id;
private Map<String, ABean> attributes;
private Map<String, GBean> underGroups;
}
public class ABean {
private String attr_id;
}
顺序读取csv文件是可以的，我一直在调查如何使用递归来存储描述数据，但找不到方法。
提前感谢您的任何算法创意。
我希望这会让你想到这个......我不得不承认我没有想法：s
答案 0 :(得分：4)
这是一个解决方案，添加评论作为练习......
public class Test {
public static void main(String[] args) {
List<Record> records = new ArrayList<Record>() {
{
add(new Record("M1", "", "G1", "A1"));
add(new Record("M1", "", "G1", "A2"));
add(new Record("M1", "G1", "G2", "A3"));
add(new Record("M1", "G1", "G2", "A4"));
}
};
MessageContainer messageContainer = new MessageContainer();
for (Record record : records) {
messageContainer.addOrUpdateMessage(record);
}
}
private static class Record {
final String messageId;
final String parentGroupId;
final String groupId;
final String attributeId;
public Record(String messageId, String parentGroupId, String groupId, String attributeId) {
super();
this.messageId = messageId;
this.parentGroupId = parentGroupId;
this.groupId = groupId;
this.attributeId = attributeId;
}
}
private static class MessageContainer {
Map<String, MBean> messages = new HashMap<String, MBean>();
public void addOrUpdateMessage(Record record) {
MBean mBean = messages.get(record.messageId);
if (mBean == null) {
mBean = new MBean(record.messageId);
messages.put(record.messageId, mBean);
}
mBean.addOrUpdateGroup(record);
}
}
private static class MBean {
private final String mes_id;
private final Map<String, GBean> groups = new HashMap<String, GBean>();
public MBean(String mesId) {
super();
mes_id = mesId;
}
public void addOrUpdateGroup(Record record) {
String groupToHandle = (record.parentGroupId != "" ? record.parentGroupId : record.groupId);
GBean gBean = groups.get(groupToHandle);
if (gBean == null) {
gBean = new GBean(groupToHandle);
groups.put(groupToHandle, gBean);
}
gBean.addOrUpdateGroup(record);
}
}
private static class GBean {
private final String groupId;
private final Map<String, ABean> attributes = new HashMap<String, ABean>();
private final Map<String, GBean> underGroups = new HashMap<String, GBean>();
public GBean(String groupId) {
super();
this.groupId = groupId;
}
public void addOrUpdateGroup(Record record) {
if (groupId == record.parentGroupId) {
GBean child = underGroups.get(record.groupId);
if (child == null) {
child = new GBean(record.groupId);
underGroups.put(record.groupId, child);
}
child.addOrUpdateGroup(record);
} else if (groupId == record.groupId) {
attributes.put(record.attributeId, new ABean(record.attributeId));
} else {
throw new RuntimeException("Unexpected state [recordParentGroupId="+record.parentGroupId+", recordGroupId="+record.groupId+", groupId="+groupId+"]");
}
}
private static class ABean {
private final String attr_id;
public ABean(String attrId) {
super();
attr_id = attrId;
}
}
}
}
答案 1 :(得分：1)
您可以尝试以更一般的方式查看问题，请看下面的内容：
private void buildTree(final Node<T> rootNode, final ArrayList<Node<T>> groupNodes) {
for (final Node<T> parentNode : groupNodes) {
if (parentNode.getParent() == rootNode) {
parentNode.setParent(rootNode);
rootNode.addChild(parentNode);
}
for (final Node<T> childNode : groupNodes) {
if (parentNode.getData().getGroupId().equalsIgnoreCase(childNode.getData().getParentId())) {
childNode.setParent(parentNode);
parentNode.addChild(childNode);
}
}
}
}
我的Node课程对象（Getter）有一个Setter和Data，其他属性中包含GroupId和ParentId属性
答案 2 :(得分：0)
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
/**
* A program that takes a comma seperated tree values and converts it into an image
* Ex: root-child1,root-child2,child1-children1,child2-children2...
* */
public class DrawGraph {
private Hashtable listparent = new Hashtable();
private Hashtable keyerrors = new Hashtable();
private Hashtable nodetree = new Hashtable();
private Hashtable connectNodes = new Hashtable();
private LinkedList rowsLinkedList = new LinkedList();
private static int start_xaxis = 0;
private static int start_yaxis = 40;
private static int xaxis = 800;
private static int yaxis = 600;
private static int end_xaxis = 0;
private static int maxy = 0;
private static int rectx = 0;
private static int recty = 0;
private int rows = 0;
private static String root;
private static Graphics2D g;
private static int bigx = 0;
private int bigy = 0;
private Hashtable _listparent = new Hashtable();
private Hashtable _keyerrors = new Hashtable();
private Hashtable _nodetree = new Hashtable();
private Hashtable _connectNodes = new Hashtable();
private LinkedList _rowsLinkedList = new LinkedList();
private static int _start_xaxis = 0;
private static int _start_yaxis = 40;
private static int _xaxis = 1000;
private static int _yaxis = 800;
private static int _end_xaxis = 0;
private static int _maxy = 0;
private static int _rectx = 0;
private static int _recty = 0;
private int _rows = 0;
private static String _root;
private static Graphics2D _g;
public static void main(String args[]) {
if (args.length == 0) {
System.out.println("USAGE: ");
System.out.println("DrawGraph <queryString> <imagelocation> ");
}
DrawGraph myn = new DrawGraph();
args[0] = "root(1/2)-child1,root-child2,child1-children1,child2-children2(test1/test2)";
args[1] = "c:/test.jpeg";
myquery = args[0];
myoutput = args[1];
myn.initialize(args[0], args[1]);
}
private static String myquery = new String();
private static String myoutput = new String();
public String getErrors(String qstring) {
StringBuffer sb = new StringBuffer();
String[] namevalues = qstring.split(",");
for (int i = 0; i < namevalues.length; i++) {
String _key = namevalues[i].split("-")[0];
String _children = namevalues[i].split("-")[1];
String[] errors = _key.split("\\(");
String[] errorsc = _children.split("\\(");
String mykey = errors[0];
String mychildrenkey = errorsc[0];
LinkedList lk = new LinkedList();
if (null != listparent.get(mychildrenkey)) {
lk = (LinkedList) listparent.get(mychildrenkey);
}
lk.add(mykey);
listparent.put(mychildrenkey, lk);
if (i == 0) {
root = mykey;
}
LinkedList _chil = new LinkedList();
try {
_chil = (LinkedList) nodetree.get(mykey);
if (null == _chil) {
_chil = new LinkedList();
}
} catch (Exception ee) {
}
_chil.add(errorsc[0]);
nodetree.put(mykey, _chil);
sb.append(mykey + "-" + _children + ",");
LinkedList l = new LinkedList();
if (null != keyerrors.get(mykey)) {
l = (LinkedList) keyerrors.get(mykey);
}
if (errors.length > 1) {
String[] ers = errors[1].split("/");
for (int j = 0; j < ers.length; j++) {
l.add(ers[j]);
}
}
keyerrors.put(mykey, l);
LinkedList lc = new LinkedList();
if (null != keyerrors.get(mychildrenkey)) {
lc = (LinkedList) keyerrors.get(mychildrenkey);
}
if (errorsc.length > 1) {
String[] ersc = errorsc[1].split("/");
for (int j = 0; j < ersc.length; j++) {
lc.add(ersc[j]);
}
}
keyerrors.put(mychildrenkey, lc);
}
return (sb.toString());
}
public void initialize(String queryString, String outputfile) {
getErrors(queryString);
rowsLinkedList.add(root);
String[] str = {root};
drawTree(str);
createImage(root, outputfile);
}
public void reinitialize(String queryString, String outputfile, int _xaxis, int _yaxis) {
listparent = new Hashtable();
keyerrors = new Hashtable();
nodetree = new Hashtable();
connectNodes = new Hashtable();
rowsLinkedList = new LinkedList();
System.out.println(_xaxis);
getErrors(queryString);
rowsLinkedList.add(root);
String[] str = {root};
drawTree(str);
createImage(_xaxis, _yaxis, root, outputfile);
}
public void drawTree(String[] node) {
String[] a = getGreatChildren(node);
if (a.length > 0) {
drawTree(a);
}
}
public String[] getGreatChildren(String[] children) {
StringBuffer sb = new StringBuffer();
LinkedList ll = new LinkedList();
for (int i = 0; i < children.length; i++) {
if (null != getChildren(children[i])) {
LinkedList temp = getChildren(children[i]);
Iterator itr = temp.iterator();
while (itr.hasNext()) {
String chld = itr.next().toString();
sb.append(chld);
sb.append(",");
ll.add(chld);
}
}
}
rows++;
if (sb.toString().length() > 0) {
rowsLinkedList.add(rows, sb.toString());
}
return convertLinkedListtoStringArray(ll);
}
public LinkedList getChildren(String node) {
LinkedList l = new LinkedList();
try {
l = (LinkedList) nodetree.get(node);
return l;
} catch (Exception ee) {
}
return null;
}
public String[] convertLinkedListtoStringArray(LinkedList l) {
String[] strnodes = null;
int size = l.size();
strnodes = new String[size];
Object[] objectArray = l.toArray();
new ArrayList();
for (int i = 0; i < size; i++) {
strnodes[i] = objectArray[i].toString();
}
return strnodes;
}
private String[] removeDuplicates(String[] l) {
Hashtable h = new Hashtable();
for (int i = 0; i < l.length; i++) {
h.put(l[i], l[i]);
}
java.util.Enumeration enk = h.keys();
LinkedList ll = new LinkedList();
while (enk.hasMoreElements()) {
String _as = enk.nextElement().toString();
ll.add(_as);
}
return convertLinkedListtoStringArray(ll);
}
private void tmpinitialize() {
_listparent = new Hashtable(listparent);
_keyerrors = new Hashtable(keyerrors);
_nodetree = new Hashtable(nodetree);
_connectNodes = connectNodes;
_rowsLinkedList = rowsLinkedList;
_start_xaxis = start_xaxis;
_start_yaxis = start_yaxis;
_xaxis = xaxis;
_yaxis = yaxis;
_end_xaxis = end_xaxis;
_maxy = maxy;
_rectx = rectx;
_recty = recty;
_rows = rows;
_root = root;
}
private void reset() {
_listparent = listparent;
_keyerrors = keyerrors;
_nodetree = nodetree;
_connectNodes = connectNodes;
_rowsLinkedList = rowsLinkedList;
_start_xaxis = start_xaxis;
_start_yaxis = start_yaxis;
_xaxis = xaxis;
_yaxis = yaxis;
_end_xaxis = end_xaxis;
_maxy = maxy;
_rectx = rectx;
_recty = recty;
_rows = rows;
_root = root;
}
public void calculateXY() {
tmpinitialize();
Hashtable _allh = new Hashtable();
int _noofrows = _rowsLinkedList.size();
int _mxy = start_yaxis;
for (int i = 0; i < _noofrows; i++) {
String[] _tmpnodes = removeDuplicates(((String) _rowsLinkedList.get(i)).split(","));
int _parts = calculateXY(_tmpnodes.length);
start_yaxis = _mxy + 60;
end_xaxis = 0;
int _tmpy = start_yaxis;
int _tmpx = 0;
for (int j = 0; j < _tmpnodes.length; j++) {
try {
if (j + 1 == 1) {
start_xaxis = _parts * (j + 1) - 20;
} else {
start_xaxis = _tmpx + _parts;// * (j + 1) - 50;
}
_tmpx = start_xaxis;
start_yaxis = _tmpy;
if (null == _allh.get(_tmpnodes[j])) {
drawNode(_tmpnodes[j]);
}
_allh.put(_tmpnodes[j], _tmpnodes[j]);
if (start_yaxis >= _mxy) {
_mxy = start_yaxis;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public void createImage(String startNode, String outputfile) {
BufferedImage image = new BufferedImage(xaxis, yaxis,
BufferedImage.TYPE_INT_RGB);
g = (Graphics2D) image.createGraphics();
g.setColor(Color.white);
g.fillRoundRect(0, 0, xaxis, yaxis, 0, 0);
g.setColor(Color.white);
Font f = new Font("SansSerif", Font.BOLD, 20);
g.setFont(f);
Hashtable allh = new Hashtable();
int noofrows = rowsLinkedList.size();
int mxy = start_yaxis;
for (int i = 0; i < noofrows; i++) {
String[] tmpnodes = removeDuplicates(((String) rowsLinkedList.get(i)).split(","));
int parts = calculateXY(tmpnodes.length);
start_yaxis = mxy + 60;
end_xaxis = 0;
int tmpy = start_yaxis;
int tmpx = 0;
int stringwidth = 0;
for (int j = 0; j < tmpnodes.length; j++) {
try {
if (j + 1 == 1) {
start_xaxis = parts * (j + 1) - 20;
} else {
start_xaxis = tmpx + parts;// * (j + 1) - 50;
}
tmpx = start_xaxis;
start_yaxis = tmpy;
if (null == allh.get(tmpnodes[j])) {
drawNode(tmpnodes[j]);
}
allh.put(tmpnodes[j], tmpnodes[j]);
if (start_yaxis >= mxy) {
mxy = start_yaxis;
}
FontMetrics ff = g.getFontMetrics();
stringwidth += (start_xaxis + ff.stringWidth(tmpnodes[j]));
} catch (Exception e) {
e.printStackTrace();
}
}
if (stringwidth >= bigx) {
bigx = stringwidth;
}
System.out.println("Row " + i + " " + stringwidth);
}
xaxis = bigx;
yaxis = mxy + 40;
System.out.println(xaxis);
start_xaxis = 0;
start_yaxis = 40;
end_xaxis = 0;
maxy = 0;
rectx = 0;
recty = 0;
rows = 0;
reinitialize(myquery, myoutput, bigx, mxy + 40);
}
public void createImage(int _xaxis, int _yaxis, String startNode, String outputfile) {
BufferedImage image = new BufferedImage(_xaxis, _yaxis,
BufferedImage.TYPE_INT_RGB);
g = (Graphics2D) image.createGraphics();
g.setColor(Color.white);
g.fillRoundRect(0, 0, xaxis, yaxis, 0, 0);
g.setColor(Color.white);
Font f = new Font("SansSerif", Font.BOLD, 20);
g.setFont(f);
Hashtable allh = new Hashtable();
int noofrows = rowsLinkedList.size();
int mxy = start_yaxis;
for (int i = 0; i < noofrows; i++) {
String[] tmpnodes = removeDuplicates(((String) rowsLinkedList.get(i)).split(","));
int parts = calculateXY(tmpnodes.length);
start_yaxis = mxy + 60;
end_xaxis = 0;
int tmpy = start_yaxis;
int tmpx = 0;
for (int j = 0; j < tmpnodes.length; j++) {
try {
if (j + 1 == 1) {
start_xaxis = parts * (j + 1) - 20;
} else {
start_xaxis = tmpx + parts;// * (j + 1) - 50;
}
tmpx = start_xaxis;
start_yaxis = tmpy;
if (null == allh.get(tmpnodes[j])) {
drawNode(tmpnodes[j]);
}
allh.put(tmpnodes[j], tmpnodes[j]);
if (start_yaxis >= mxy) {
mxy = start_yaxis;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
try {
FileOutputStream jpegout = new FileOutputStream(
new File(outputfile));
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(jpegout);
encoder.encode(image);
} catch (Exception ee) {
ee.printStackTrace();
}
}
private int getMaxFm(String node) {
int maxfm = 0;
FontMetrics fm = g.getFontMetrics();
maxfm = fm.stringWidth(node) + 10;
LinkedList errorslist = (LinkedList) keyerrors.get(node);
Iterator itr = errorslist.iterator();
while (itr.hasNext()) {
String eacherror = itr.next().toString();
int tmpfm = fm.stringWidth(eacherror) + 10;
if (tmpfm >= maxfm) {
maxfm = tmpfm;
}
}
return maxfm;
}
private int calculateXY(int nodecount) {
try {
return xaxis / (nodecount + 1);
} catch (Exception e) {
e.printStackTrace();
}
return 0;
}
public void drawNode(String node) {
Font f = new Font("SansSerif", Font.BOLD | Font.BOLD, 20);
g.setFont(f);
recty = 0;
maxy = 0;
FontMetrics fm = g.getFontMetrics();
int w = fm.stringWidth(node) + 10;
int h = fm.getHeight() + 4;
int x = 0;
x = start_xaxis;
int y = 0;
y = start_yaxis;
int startrect_xaxis = x - w / 2;
if (startrect_xaxis < end_xaxis) {
x = end_xaxis + w / 2 + 10;
startrect_xaxis = x - w / 2;
}
int startnode_xaxis = x - (w - 10) / 2;
int startnode_yaxis = (y - (h - 4) / 2) + fm.getAscent();
int startrect_yaxis = y - h / 2;
int xrectlength = w - 1;
int yrectlength = h - 1;
int end_yaxis = startrect_yaxis + yrectlength + 1;
end_xaxis = startrect_xaxis + xrectlength + 1;
g.setColor(Color.white);
g.fillRect(startrect_xaxis, startrect_yaxis, w, h);
g.setColor(Color.BLACK);
g.drawString(node, startnode_xaxis, startnode_yaxis);
recty = yrectlength;
if (null != keyerrors.get(node)) {
rectx = 0;
f = new Font("SansSerif", Font.PLAIN, 20);
g.setFont(f);
drawNodeErrors(node, startnode_xaxis, end_yaxis);
if (rectx <= xrectlength) {
rectx = xrectlength;
}
g.setColor(Color.black);
calculateEdges(node, startrect_xaxis, startrect_yaxis, rectx, recty + 2);
g.setColor(Color.GRAY);
g.drawRoundRect(startrect_xaxis, startrect_yaxis, rectx, recty + 2, 15, 15);
start_yaxis = startrect_yaxis + recty;
} else {
g.setColor(Color.black);
calculateEdges(node, startrect_xaxis, startrect_yaxis, xrectlength, yrectlength);
g.setColor(Color.GRAY);
g.drawRoundRect(startrect_xaxis, startrect_yaxis, xrectlength, yrectlength, 15, 15);
}
int bb = startrect_xaxis + xrectlength;
if (bb >= bigx) {
bigx = bb;
}
}
public void drawNodeErrors(String node, int startnode_xaxis, int end_yaxis) {
Iterator itr = ((LinkedList) keyerrors.get(node)).iterator();
while (itr.hasNext()) {
int startrect_xaxis = 0;
int x = 0;
int y = 0;
int xrectlength = 0;
node = itr.next().toString().replaceAll("\\)", "");
FontMetrics fm = g.getFontMetrics();
int w = fm.stringWidth(node) + 10;
int h = fm.getHeight() + 4;
x = start_xaxis;
start_yaxis = start_yaxis + 20;
y = start_yaxis;
startrect_xaxis = x - w / 2;
if (startrect_xaxis < end_xaxis) {
x = end_xaxis + w / 2 + 10;
startrect_xaxis = x - w / 2;
}
int startnode_yaxis = (y - (h - 4) / 2) + fm.getAscent();
xrectlength = w - 1;
g.setColor(Color.RED);
g.drawString(node, startnode_xaxis, startnode_yaxis);
recty += fm.getAscent();
if (xrectlength >= rectx) {
rectx = xrectlength;
}
if (recty >= maxy) {
maxy = recty;
}
}
}
private void calculateEdges(String node, int startxaxis, int startyaxis,
int xlength, int ylength) {
int x1 = startxaxis + xlength / 2;
int y1 = startyaxis;
int x2 = x1;
int y2 = startyaxis + ylength;
middle m = new middle();
m.setX1(x1);
m.setY1(y1);
m.setX2(x2);
m.setY2(y2);
m.setStartxaxis(startxaxis);
connectNodes.put(node, m);
try {
String[] myparent = convertLinkedListtoStringArray((LinkedList) listparent.get(node));
for (int j = 0; j < myparent.length; j++) {
middle par = (middle) connectNodes.get(myparent[j]);
int p[] = par.getBottom();
int c[] = m.getTop();
g.setColor(Color.black);
int parentrectlength = p[0] - par.getStartxaxis();
int parentendxaxis = par.getStartxaxis()
+ (parentrectlength * 2);
if (c[0] > par.getStartxaxis() && c[0] < parentendxaxis) {
drawArrow(g, c[0], p[1], c[0], c[1]);
drawMArrow(g, c[0], c[1], c[0], p[1]);
} else {
drawArrow(g, p[0], p[1], c[0], c[1]);
drawMArrow(g, c[0], c[1], p[0], p[1]);
}
}
} catch (Exception ee) {
}
}
private void drawArrow(Graphics2D g, int x, int y, int xx, int yy) {
float arrowWidth = 6.0f;
float theta = 0.423f;
int[] xPoints = new int[3];
int[] yPoints = new int[3];
float[] vecLine = new float[2];
float[] vecLeft = new float[2];
float fLength;
float th;
float ta;
float baseX, baseY;
xPoints[ 0] = xx;
yPoints[ 0] = yy;
vecLine[ 0] = (float) xPoints[ 0] - x;
vecLine[ 1] = (float) yPoints[ 0] - y;
vecLeft[ 0] = -vecLine[ 1];
vecLeft[ 1] = vecLine[ 0];
fLength = (float) Math.sqrt(vecLine[0] * vecLine[0] + vecLine[1] * vecLine[1]);
th = arrowWidth / (2.0f * fLength);
ta = arrowWidth / (2.0f * ((float) Math.tan(theta) / 2.0f) * fLength);
baseX = ((float) xPoints[ 0] - ta * vecLine[0]);
baseY = ((float) yPoints[ 0] - ta * vecLine[1]);
xPoints[ 1] = (int) (baseX + th * vecLeft[0]);
yPoints[ 1] = (int) (baseY + th * vecLeft[1]);
xPoints[ 2] = (int) (baseX - th * vecLeft[0]);
yPoints[ 2] = (int) (baseY - th * vecLeft[1]);
g.drawLine(x, y, (int) baseX, (int) baseY);
g.fillPolygon(xPoints, yPoints, 3);
}
private void drawMArrow(Graphics2D g, int x, int y, int xx, int yy) {
float arrowWidth = 6.0f;
float theta = 0.423f;
int[] xPoints = new int[3];
int[] yPoints = new int[3];
float[] vecLine = new float[2];
float[] vecLeft = new float[2];
float fLength;
float th;
float ta;
float baseX, baseY;
xPoints[ 0] = xx;
yPoints[ 0] = yy;
vecLine[ 0] = (float) xPoints[ 0] - x;
vecLine[ 1] = (float) yPoints[ 0] - y;
vecLeft[ 0] = -vecLine[ 1];
vecLeft[ 1] = vecLine[ 0];
fLength = (float) Math.sqrt(vecLine[0] * vecLine[0] + vecLine[1] * vecLine[1]);
th = arrowWidth / (2.0f * fLength);
ta = arrowWidth / (2.0f * ((float) Math.tan(theta) / 2.0f) * fLength);
baseX = ((float) xPoints[ 0] - ta * vecLine[0]);
baseY = ((float) yPoints[ 0] - ta * vecLine[1]);
xPoints[ 1] = (int) (baseX + th * vecLeft[0]);
yPoints[ 1] = (int) (baseY + th * vecLeft[1]);
xPoints[ 2] = (int) (baseX - th * vecLeft[0]);
yPoints[ 2] = (int) (baseY - th * vecLeft[1]);
g.fillPolygon(xPoints, yPoints, 3);
}
class middle {
int x1;
int y1;
int x2;
int y2;
int startxaxis;
public int getStartxaxis() {
return startxaxis;
}
public void setStartxaxis(int startxaxis) {
this.startxaxis = startxaxis;
}
public int getX1() {
return x1;
}
public void setX1(int x1) {
this.x1 = x1;
}
public int getY1() {
return y1;
}
public void setY1(int y1) {
this.y1 = y1;
}
public int getX2() {
return x2;
}
public void setX2(int x2) {
this.x2 = x2;
}
public int getY2() {
return y2;
}
public void setY2(int y2) {
this.y2 = y2;
}
public int[] getTop() {
int t[] = new int[2];
t[0] = this.x1;
t[1] = this.y1;
return t;
}
public int[] getBottom() {
int t[] = new int[2];
t[0] = this.x2;
t[1] = this.y2;
return t;
}
}
}