398 lines
12 KiB
TypeScript
398 lines
12 KiB
TypeScript
import { FederatedPointerEvent, IHitArea, IPointData, Point } from 'pixi.js';
|
|
import {
|
|
GraphicDrawAssistant,
|
|
GraphicIdGenerator,
|
|
GraphicInteractionPlugin,
|
|
JlDrawApp,
|
|
JlGraphic,
|
|
linePoint,
|
|
} from 'src/jl-graphic';
|
|
|
|
import {
|
|
IAxleCountingSectionData,
|
|
AxleCountingSection,
|
|
AxleCountingSectionTemplate,
|
|
AxleCountingSectionConsts,
|
|
ITurnoutPosRefData,
|
|
} from './AxleCountingSection';
|
|
import { AxleCounting } from '../axleCounting/AxleCounting';
|
|
import { Turnout, TurnoutPort } from '../turnout/Turnout';
|
|
import { createRelatedRefProto } from '../CommonGraphics';
|
|
|
|
function hasCommonElements(arr1: string[], arr2: string[]) {
|
|
for (let i = 0; i < arr1.length; i++) {
|
|
if (arr2.includes(arr1[i])) {
|
|
return arr1[i];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function hasSamePosition(point1: IPointData, point2: IPointData): boolean {
|
|
if (
|
|
Math.abs(point1.x - point2.x) < 20 &&
|
|
Math.abs(point1.y - point2.y) < 20
|
|
) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export interface IAxleCountingSectionDrawOptions {
|
|
newData: () => IAxleCountingSectionData;
|
|
}
|
|
|
|
export class AxleCountingSectionDraw extends GraphicDrawAssistant<
|
|
AxleCountingSectionTemplate,
|
|
IAxleCountingSectionData
|
|
> {
|
|
codeGraph: AxleCountingSection;
|
|
constructor(app: JlDrawApp, template: AxleCountingSectionTemplate) {
|
|
super(app, template, 'sym_o_circle', '不展示');
|
|
this.codeGraph = this.graphicTemplate.new();
|
|
this.container.addChild(this.codeGraph);
|
|
AxleCountingSectionInteraction.init(app);
|
|
}
|
|
|
|
bind(): void {
|
|
super.bind();
|
|
this.codeGraph.loadData(this.graphicTemplate.datas);
|
|
this.codeGraph.doRepaint();
|
|
}
|
|
|
|
clearCache(): void {
|
|
//this.codeGraph.destroy();
|
|
}
|
|
onLeftDown(e: FederatedPointerEvent): void {
|
|
this.container.position.copyFrom(this.toCanvasCoordinates(e.global));
|
|
this.createAndStore(true);
|
|
}
|
|
|
|
redraw(p: Point): void {
|
|
this.container.position.copyFrom(p);
|
|
}
|
|
prepareData(data: IAxleCountingSectionData): boolean {
|
|
data.transform = this.container.saveTransform();
|
|
return true;
|
|
}
|
|
draw(
|
|
graphics: AxleCounting[],
|
|
commonElement: JlGraphic[],
|
|
map: Map<string, number>,
|
|
turoutPos?: number
|
|
) {
|
|
if (
|
|
map.has(`${graphics[0].id}+${graphics[1].id}`) ||
|
|
map.has(`${graphics[1].id}+${graphics[0].id}`)
|
|
)
|
|
return;
|
|
const axleCountingSection = new AxleCountingSection();
|
|
axleCountingSection.loadData(this.graphicTemplate.datas);
|
|
axleCountingSection.datas.points = [
|
|
graphics[0].position,
|
|
graphics[1].position,
|
|
];
|
|
axleCountingSection.id = GraphicIdGenerator.next();
|
|
const paRef = createRelatedRefProto(graphics[0].type, graphics[0].id);
|
|
const pbRef = createRelatedRefProto(graphics[1].type, graphics[1].id);
|
|
const turnoutPosData: ITurnoutPosRefData[] = [];
|
|
if (commonElement[0].type == 'Turnout') {
|
|
commonElement.forEach((Turnout, i) => {
|
|
if (commonElement.length == 2) {
|
|
if (turoutPos == -1) {
|
|
if (i == 1) {
|
|
turnoutPosData.push({
|
|
id: Turnout.id,
|
|
position: 1,
|
|
});
|
|
} else {
|
|
turnoutPosData.push({
|
|
id: Turnout.id,
|
|
position: 0,
|
|
});
|
|
}
|
|
} else
|
|
turnoutPosData.push({
|
|
id: Turnout.id,
|
|
position: 0,
|
|
});
|
|
} else {
|
|
if (turoutPos == 0) {
|
|
turnoutPosData.push({
|
|
id: Turnout.id,
|
|
position: 0,
|
|
});
|
|
} else {
|
|
turnoutPosData.push({
|
|
id: Turnout.id,
|
|
position: 1,
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
axleCountingSection.datas.paRef = paRef;
|
|
axleCountingSection.datas.pbRef = pbRef;
|
|
axleCountingSection.datas.turnoutPosRef = turnoutPosData;
|
|
this.storeGraphic(axleCountingSection);
|
|
axleCountingSection.loadRelations();
|
|
}
|
|
|
|
oneGenerates() {
|
|
const map = new Map();
|
|
const axleCountingSections =
|
|
this.app.queryStore.queryByType<AxleCountingSection>(
|
|
AxleCountingSection.Type
|
|
);
|
|
axleCountingSections.forEach((axleCountingSection) => {
|
|
map.set(
|
|
`${axleCountingSection.datas.paRef?.id}+${axleCountingSection.datas.pbRef?.id}`,
|
|
1
|
|
);
|
|
});
|
|
const axleCountings = this.app.queryStore.queryByType<AxleCounting>(
|
|
AxleCounting.Type
|
|
);
|
|
const hasfourTurnout: AxleCounting[][] = [];
|
|
axleCountings.forEach((axleCounting) => {
|
|
const refDeviceTarget = axleCounting.datas.axleCountingRef.map(
|
|
(ref) => ref.id
|
|
);
|
|
for (let i = 0; i < axleCountings.length - 1; i++) {
|
|
if (axleCountings[i].id == axleCounting.id) return;
|
|
const refDevice = axleCountings[i].datas.axleCountingRef.map(
|
|
(ref) => ref.id
|
|
);
|
|
const commonElementId = hasCommonElements(refDeviceTarget, refDevice);
|
|
if (commonElementId) {
|
|
const commonElement = this.app.queryStore.queryById(commonElementId);
|
|
let draw = true;
|
|
let turoutPos = 0;
|
|
//道岔BC端处的计轴不构成计轴区段
|
|
if (commonElement.type == 'Turnout') {
|
|
let targetPort, port;
|
|
axleCounting.datas.axleCountingRef.forEach((ref) => {
|
|
if (ref.id == commonElementId) {
|
|
targetPort = ref.devicePort;
|
|
}
|
|
});
|
|
axleCountings[i].datas.axleCountingRef.forEach((ref) => {
|
|
if (ref.id == commonElementId) {
|
|
port = ref.devicePort;
|
|
}
|
|
});
|
|
if (
|
|
(targetPort == 1 && port == 2) ||
|
|
(targetPort == 2 && port == 1)
|
|
) {
|
|
draw = false;
|
|
}
|
|
if (targetPort == 2 || port == 2) {
|
|
turoutPos = 1;
|
|
}
|
|
}
|
|
if (draw) {
|
|
this.draw(
|
|
[axleCounting, axleCountings[i]],
|
|
[commonElement],
|
|
map,
|
|
turoutPos
|
|
);
|
|
}
|
|
}
|
|
if (hasSamePosition(axleCounting, axleCountings[i])) {
|
|
hasfourTurnout.push([axleCounting, axleCountings[i]]);
|
|
}
|
|
}
|
|
});
|
|
//补4个道岔处的BB连接处的计轴区段
|
|
const fourAxleCounting: {
|
|
axleCounting: AxleCounting;
|
|
refTurout: Turnout;
|
|
}[] = [];
|
|
hasfourTurnout.forEach((axleCountings) => {
|
|
axleCountings.forEach((axleCounting) => {
|
|
//计轴关联的道岔
|
|
const axleCountingRelations =
|
|
axleCounting.relationManage.getRelationsOfGraphicAndOtherType(
|
|
axleCounting,
|
|
Turnout.Type
|
|
);
|
|
axleCountingRelations.forEach((relation) => {
|
|
const refTurnout = relation.getOtherGraphic<Turnout>(axleCounting);
|
|
//道岔关联的计轴
|
|
const turnoutRelations =
|
|
refTurnout.relationManage.getRelationsOfGraphicAndOtherType(
|
|
refTurnout,
|
|
AxleCounting.Type
|
|
);
|
|
turnoutRelations.forEach((relation) => {
|
|
const refAxleCounting =
|
|
relation.getOtherGraphic<AxleCounting>(refTurnout);
|
|
if (
|
|
refAxleCounting.id !== axleCountings[0].id &&
|
|
refAxleCounting.id !== axleCountings[1].id
|
|
) {
|
|
fourAxleCounting.push({
|
|
axleCounting: refAxleCounting,
|
|
refTurout: refTurnout,
|
|
});
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
for (let x = 0; x < fourAxleCounting.length; x += 4) {
|
|
const AxleCountings = fourAxleCounting.slice(x, x + 4);
|
|
for (let y = 0; y < 4; y++) {
|
|
if (
|
|
fourAxleCounting[x].axleCounting.id ==
|
|
AxleCountings[y].axleCounting.id
|
|
)
|
|
continue;
|
|
if (
|
|
fourAxleCounting[x].axleCounting.y == AxleCountings[y].axleCounting.y
|
|
) {
|
|
this.draw(
|
|
[fourAxleCounting[x].axleCounting, AxleCountings[y].axleCounting],
|
|
[fourAxleCounting[x].refTurout, AxleCountings[y].refTurout],
|
|
map
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
for (let y = 0; y < 4; y++) {
|
|
if (
|
|
fourAxleCounting[x + 1].axleCounting.id ==
|
|
AxleCountings[y].axleCounting.id
|
|
)
|
|
continue;
|
|
if (
|
|
fourAxleCounting[x + 1].axleCounting.y ==
|
|
AxleCountings[y].axleCounting.y
|
|
) {
|
|
this.draw(
|
|
[
|
|
fourAxleCounting[x + 1].axleCounting,
|
|
AxleCountings[y].axleCounting,
|
|
],
|
|
[fourAxleCounting[x + 1].refTurout, AxleCountings[y].refTurout],
|
|
map
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//补删除计轴后的区段
|
|
const axleCountingAll = this.app.queryStore.queryByType<AxleCounting>(
|
|
AxleCounting.Type
|
|
);
|
|
const deleteRefTurout: string[] = [];
|
|
const redawAxleCounting: AxleCounting[] = [];
|
|
axleCountingAll.forEach((axleCounting) => {
|
|
const axleCountingRelations =
|
|
axleCounting.relationManage.getRelationsOfGraphicAndOtherType(
|
|
axleCounting,
|
|
AxleCountingSection.Type
|
|
);
|
|
if (
|
|
axleCounting.datas.axleCountingRef.length == 2 &&
|
|
axleCountingRelations.length < 2
|
|
) {
|
|
axleCounting.datas.axleCountingRef.forEach((ref) => {
|
|
if (ref.deviceType == 1) {
|
|
redawAxleCounting.push(axleCounting);
|
|
}
|
|
if (ref.deviceType == 1 && !deleteRefTurout.includes(ref.id)) {
|
|
deleteRefTurout.push(ref.id);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
deleteRefTurout.forEach((id) => {
|
|
const turout = this.app.queryStore.queryById(id);
|
|
const turoutRelations =
|
|
turout.relationManage.getRelationsOfGraphicAndOtherType(
|
|
turout,
|
|
Turnout.Type
|
|
);
|
|
const refTurout = turoutRelations[0].getOtherGraphic(turout);
|
|
const refs = refTurout.relationManage
|
|
.getRelationsOfGraphicAndOtherType(refTurout, AxleCounting.Type)
|
|
.find(
|
|
(relation) =>
|
|
relation.getRelationParam(refTurout).param !== TurnoutPort.C
|
|
);
|
|
const refAxleCountin = refs?.getOtherGraphic(refTurout) as AxleCounting;
|
|
this.draw(
|
|
[refAxleCountin, redawAxleCounting[0]],
|
|
[refTurout, turout],
|
|
map
|
|
);
|
|
this.draw(
|
|
[refAxleCountin, redawAxleCounting[1]],
|
|
[refTurout, turout],
|
|
map,
|
|
-1
|
|
);
|
|
});
|
|
}
|
|
}
|
|
class AxleCountingSectionGraphicHitArea implements IHitArea {
|
|
axleCountingSection: AxleCountingSection;
|
|
constructor(axleCountingSection: AxleCountingSection) {
|
|
this.axleCountingSection = axleCountingSection;
|
|
}
|
|
contains(x: number, y: number): boolean {
|
|
for (let i = 1; i < this.axleCountingSection.datas.points.length; i++) {
|
|
const p1 = this.axleCountingSection.datas.points[i - 1];
|
|
const p2 = this.axleCountingSection.datas.points[i];
|
|
if (linePoint(p1, p2, { x, y }, AxleCountingSectionConsts.lineWidth)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
export class AxleCountingSectionInteraction extends GraphicInteractionPlugin<AxleCountingSection> {
|
|
static Name = 'AxleCountingSection_transform';
|
|
constructor(app: JlDrawApp) {
|
|
super(AxleCountingSectionInteraction.Name, app);
|
|
}
|
|
static init(app: JlDrawApp) {
|
|
return new AxleCountingSectionInteraction(app);
|
|
}
|
|
filter(...grahpics: JlGraphic[]): AxleCountingSection[] | undefined {
|
|
return grahpics
|
|
.filter((g) => g.type === AxleCountingSection.Type)
|
|
.map((g) => g as AxleCountingSection);
|
|
}
|
|
bind(g: AxleCountingSection): void {
|
|
g.eventMode = 'static';
|
|
g.cursor = 'pointer';
|
|
g.scalable = true;
|
|
g.transformSave = true;
|
|
g.lineGraphic.eventMode = 'static';
|
|
g.lineGraphic.cursor = 'pointer';
|
|
g.lineGraphic.hitArea = new AxleCountingSectionGraphicHitArea(g);
|
|
g.labelGraphic.eventMode = 'static';
|
|
g.labelGraphic.cursor = 'pointer';
|
|
g.labelGraphic.selectable = true;
|
|
g.labelGraphic.draggable = true;
|
|
}
|
|
unbind(g: AxleCountingSection): void {
|
|
g.eventMode = 'none';
|
|
g.scalable = false;
|
|
g.rotatable = false;
|
|
g.lineGraphic.eventMode = 'none';
|
|
g.lineGraphic.draggable = false;
|
|
g.lineGraphic.selectable = false;
|
|
g.lineGraphic.transformSave = false;
|
|
g.labelGraphic.eventMode = 'none';
|
|
g.labelGraphic.draggable = false;
|
|
g.labelGraphic.selectable = false;
|
|
g.labelGraphic.transformSave = false;
|
|
}
|
|
}
|