From 5573f7ea425eecdc5c4584704ea23173fd2607a2 Mon Sep 17 00:00:00 2001 From: dong <58670809@qq.com> Date: Mon, 10 Jul 2023 16:34:33 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=80=BB=E8=BE=91=E5=8C=BA?= =?UTF-8?q?=E6=AE=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../graphics/LogicSectionInteraction.ts | 63 ++++ src/drawApp/index.ts | 53 +++- src/graphics/logicSection/LogicSection.ts | 122 ++++++++ .../logicSection/LogicSectionDrawAssistant.ts | 273 ++++++++++++++++++ src/layouts/DrawLayout.vue | 12 + src/protos/stationLayoutGraphics.ts | 25 +- 6 files changed, 543 insertions(+), 5 deletions(-) create mode 100644 src/drawApp/graphics/LogicSectionInteraction.ts create mode 100644 src/graphics/logicSection/LogicSection.ts create mode 100644 src/graphics/logicSection/LogicSectionDrawAssistant.ts diff --git a/src/drawApp/graphics/LogicSectionInteraction.ts b/src/drawApp/graphics/LogicSectionInteraction.ts new file mode 100644 index 0000000..a800c88 --- /dev/null +++ b/src/drawApp/graphics/LogicSectionInteraction.ts @@ -0,0 +1,63 @@ +import * as pb_1 from 'google-protobuf'; +import { GraphicDataBase } from './GraphicDataBase'; +import { + ILogicSectionData, + LogicSection, +} from 'src/graphics/logicSection/LogicSection'; +import { graphicData } from 'src/protos/stationLayoutGraphics'; +import { IPointData } from 'pixi.js'; + +export class LogicSectionData + extends GraphicDataBase + implements ILogicSectionData +{ + constructor(data?: graphicData.AxleCountingSection) { + let logicSection; + if (!data) { + logicSection = new graphicData.AxleCountingSection({ + common: GraphicDataBase.defaultCommonInfo(LogicSection.Type), + }); + } else { + logicSection = data; + } + super(logicSection); + } + public get data(): graphicData.AxleCountingSection { + return this.getData(); + } + get code(): string { + return this.data.code; + } + set code(v: string) { + this.data.code = v; + } + get points(): IPointData[] { + return this.data.points; + } + set points(points: IPointData[]) { + this.data.points = points.map( + (p) => new graphicData.Point({ x: p.x, y: p.y }) + ); + } + get paRef(): graphicData.RelatedRef { + return this.data.paRef; + } + set paRef(ref: graphicData.RelatedRef) { + this.data.paRef = ref; + } + get pbRef(): graphicData.RelatedRef { + return this.data.pbRef; + } + set pbRef(ref: graphicData.RelatedRef) { + this.data.pbRef = ref; + } + clone(): LogicSectionData { + return new LogicSectionData(this.data.cloneMessage()); + } + copyFrom(data: LogicSectionData): void { + pb_1.Message.copyInto(data.data, this.data); + } + eq(other: LogicSectionData): boolean { + return pb_1.Message.equals(this.data, other.data); + } +} diff --git a/src/drawApp/index.ts b/src/drawApp/index.ts index 1f379a9..6a3576c 100644 --- a/src/drawApp/index.ts +++ b/src/drawApp/index.ts @@ -71,6 +71,12 @@ import { } from 'src/graphics/sectionLink/SectionLink'; import { SectionLinkDraw } from 'src/graphics/sectionLink/SectionLinkDrawAssistant'; import { SectionLinkData } from './graphics/SectionLinkInteraction'; +import { LogicSectionDraw } from 'src/graphics/logicSection/LogicSectionDrawAssistant'; +import { + LogicSection, + LogicSectionTemplate, +} from 'src/graphics/logicSection/LogicSection'; +import { LogicSectionData } from './graphics/LogicSectionInteraction'; // export function fromStoragePoint(p: graphicData.Point): Point { // return new Point(p.x, p.y); @@ -111,13 +117,16 @@ const RedoOptions: MenuItemOptions = { const SelectAllOptions: MenuItemOptions = { name: '全选', }; +const AllOptions: MenuItemOptions = { + name: '全部图层', +}; const linkOptions: MenuItemOptions = { name: '图层-Link', }; const axleCountingSectionOptions: MenuItemOptions = { name: '图层-计轴区段', }; -const threeLayerOptions: MenuItemOptions = { +const LogicSectionOptions: MenuItemOptions = { name: '图层-逻辑区段', }; @@ -126,7 +135,12 @@ const layerOptions: MenuItemOptions = { subMenu: [ { name: '图层菜单', - items: [linkOptions, axleCountingSectionOptions, threeLayerOptions], + items: [ + AllOptions, + linkOptions, + axleCountingSectionOptions, + LogicSectionOptions, + ], }, ], }; @@ -178,6 +192,7 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { | SeparatorDraw | SectionLinkDraw | AxleCountingSectionDraw + | LogicSectionDraw )[] = []; if (draftType === 'Line') { drawAssistants = [ @@ -211,6 +226,10 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { app, new AxleCountingSectionTemplate(new AxleCountingSectionData()) ), + new LogicSectionDraw( + app, + new LogicSectionTemplate(new LogicSectionData()) + ), ]; DrawSignalInteraction.init(app); } @@ -225,6 +244,9 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { RedoOptions.disabled = !app.opRecord.hasRedo; const axleCountingSections = app.queryStore.queryByType(AxleCountingSection.Type); + const logicSections = app.queryStore.queryByType( + LogicSection.Type + ); const sections = app.queryStore.queryByType
(Section.Type); const sectionLinks = app.queryStore.queryByType( SectionLink.Type @@ -235,6 +257,7 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { ...turnouts, ...sectionLinks, ...axleCountingSections, + ...logicSections, ]; UndoOptions.handler = () => { app.opRecord.undo(); @@ -245,6 +268,11 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { SelectAllOptions.handler = () => { app.selectAllGraphics(); }; + AllOptions.handler = () => { + disvisibleGraphics.forEach((g) => { + g.visible = true; + }); + }; linkOptions.handler = () => { disvisibleGraphics.forEach((g) => { g.visible = false; @@ -261,8 +289,13 @@ export function initDrawApp(dom: HTMLElement): JlDrawApp { axleCountingSection.visible = true; }); }; - threeLayerOptions.handler = () => { - console.log(2222); + LogicSectionOptions.handler = () => { + disvisibleGraphics.forEach((g) => { + g.visible = false; + }); + logicSections.forEach((logicSection) => { + logicSection.visible = true; + }); }; DefaultCanvasMenu.open(e.global); }); @@ -346,6 +379,9 @@ export function saveDrawDatas(app: JlDrawApp) { storage.axleCountingSections.push( (axleCountingSectionData as AxleCountingSectionData).data ); + } else if (LogicSection.Type === g.type) { + const logicSectionData = (g as LogicSection).saveData(); + storage.logicSections.push((logicSectionData as LogicSectionData).data); } }); const base64 = fromUint8Array(storage.serialize()); @@ -410,6 +446,9 @@ export async function loadDrawDatas(app: GraphicApp) { storage.axleCountingSections.forEach((axleCountingSection) => { datas.push(new AxleCountingSectionData(axleCountingSection)); }); + storage.logicSections.forEach((logicSection) => { + datas.push(new LogicSectionData(logicSection)); + }); await app.loadGraphic(datas); } else { app.loadGraphic([]); @@ -427,4 +466,10 @@ export async function loadDrawDatas(app: GraphicApp) { sectionLinks.forEach((sectionLink) => { sectionLink.visible = false; }); + const logicSections = app.queryStore.queryByType( + LogicSection.Type + ); + logicSections.forEach((logicSection) => { + logicSection.visible = false; + }); } diff --git a/src/graphics/logicSection/LogicSection.ts b/src/graphics/logicSection/LogicSection.ts new file mode 100644 index 0000000..3e6ec3d --- /dev/null +++ b/src/graphics/logicSection/LogicSection.ts @@ -0,0 +1,122 @@ +import { Graphics, IPointData } from 'pixi.js'; +import { + GraphicData, + GraphicRelationParam, + JlGraphic, + JlGraphicTemplate, + VectorText, +} from 'src/jl-graphic'; +import { IRelatedRefData, protoPort2Data } from '../CommonGraphics'; +import { SectionPort } from '../section/Section'; + +export interface ILogicSectionData extends GraphicData { + get code(): string; // 编号 + set code(v: string); + get points(): IPointData[]; // 线坐标点 + set points(points: IPointData[]); + get paRef(): IRelatedRefData | undefined; + set paRef(ref: IRelatedRefData | undefined); + get pbRef(): IRelatedRefData | undefined; + set pbRef(ref: IRelatedRefData | undefined); + clone(): ILogicSectionData; + copyFrom(data: ILogicSectionData): void; + eq(other: ILogicSectionData): boolean; +} + +export const LogicSectionConsts = { + lineColor: '0xff0000', + lineWidth: 2, +}; + +export class LogicSection extends JlGraphic { + static Type = 'LogicSection'; + lineGraphic: Graphics; + labelGraphic: VectorText; + constructor() { + super(LogicSection.Type); + this.lineGraphic = new Graphics(); + this.labelGraphic = new VectorText(); + this.labelGraphic.setVectorFontSize(14); + this.labelGraphic.anchor.set(0.5); + this.labelGraphic.style.fill = '#0f0'; + this.labelGraphic.transformSave = true; + this.labelGraphic.name = 'label'; + this.transformSave = true; + this.addChild(this.lineGraphic); + this.addChild(this.labelGraphic); + } + + get datas(): ILogicSectionData { + return this.getDatas(); + } + doRepaint(): void { + if (this.datas.points.length < 2) { + throw new Error('LogicSection坐标数据异常'); + } + this.lineGraphic.clear(); + this.lineGraphic.lineStyle( + LogicSectionConsts.lineWidth, + LogicSectionConsts.lineColor + ); + this.datas.points.forEach((p, i) => { + if (i !== 0) { + this.lineGraphic.lineTo(p.x, p.y); + } else { + this.lineGraphic.moveTo(p.x, p.y); + } + }); + this.labelGraphic.text = this.datas.code; + const labelPosition = this.datas.childTransforms?.find( + (t) => t.name === this.labelGraphic.name + )?.transform.position; + if (labelPosition) { + this.labelGraphic.position.set(labelPosition.x, labelPosition.y); + } else { + this.labelGraphic.position.set( + this.datas.points[0].x, + this.datas.points[0].y + 20 + ); + } + } + get linePoints(): IPointData[] { + return this.datas.points; + } + set linePoints(points: IPointData[]) { + const old = this.datas.clone(); + old.points = points; + this.updateData(old); + } + loadRelations() { + if (this.datas?.paRef?.id) { + this.relationManage.addRelation( + new GraphicRelationParam(this, SectionPort.A), + new GraphicRelationParam( + this.queryStore.queryById(this.datas.paRef.id), + protoPort2Data(this.datas.paRef.devicePort) + ) + ); + } + if (this.datas?.pbRef?.id) { + this.relationManage.addRelation( + new GraphicRelationParam(this, SectionPort.B), + new GraphicRelationParam( + this.queryStore.queryById(this.datas.pbRef.id), + protoPort2Data(this.datas.pbRef.devicePort) + ) + ); + } + } +} + +export class LogicSectionTemplate extends JlGraphicTemplate { + constructor(dataTemplate: ILogicSectionData) { + super(LogicSection.Type, { + dataTemplate, + }); + } + new(): LogicSection { + const logicSection = new LogicSection(); + logicSection.loadData(this.datas); + return logicSection; + } +} diff --git a/src/graphics/logicSection/LogicSectionDrawAssistant.ts b/src/graphics/logicSection/LogicSectionDrawAssistant.ts new file mode 100644 index 0000000..d04d76f --- /dev/null +++ b/src/graphics/logicSection/LogicSectionDrawAssistant.ts @@ -0,0 +1,273 @@ +import { FederatedPointerEvent, IHitArea, IPointData, Point } from 'pixi.js'; +import { + AbsorbableLine, + AbsorbablePosition, + GraphicDrawAssistant, + GraphicIdGenerator, + GraphicInteractionPlugin, + JlDrawApp, + JlGraphic, + linePoint, +} from 'src/jl-graphic'; + +import { + ILogicSectionData, + LogicSection, + LogicSectionTemplate, + LogicSectionConsts, +} from './LogicSection'; +import { AxleCounting } from '../axleCounting/AxleCounting'; +import { Turnout } 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 ILogicSectionDrawOptions { + newData: () => ILogicSectionData; +} + +export class LogicSectionDraw extends GraphicDrawAssistant< + LogicSectionTemplate, + ILogicSectionData +> { + codeGraph: LogicSection; + constructor(app: JlDrawApp, template: LogicSectionTemplate) { + super(app, template, 'sym_o_circle', '不展示'); + this.codeGraph = this.graphicTemplate.new(); + this.container.addChild(this.codeGraph); + LogicSectionInteraction.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: ILogicSectionData): boolean { + data.transform = this.container.saveTransform(); + return true; + } + draw(graphics: JlGraphic[], map: Map) { + if ( + map.has(`${graphics[0].id}+${graphics[1].id}`) || + map.has(`${graphics[1].id}+${graphics[0].id}`) + ) + return; + const logicSection = new LogicSection(); + logicSection.loadData(this.graphicTemplate.datas); + logicSection.datas.points = [graphics[0].position, graphics[1].position]; + logicSection.id = GraphicIdGenerator.next(); + const paRef = createRelatedRefProto(graphics[0].type, graphics[0].id); + const pbRef = createRelatedRefProto(graphics[1].type, graphics[1].id); + logicSection.datas.paRef = paRef; + logicSection.datas.pbRef = pbRef; + this.storeGraphic(logicSection); + logicSection.loadRelations(); + } + + oneGenerates() { + const map = new Map(); + const logicSections = this.app.queryStore.queryByType( + LogicSection.Type + ); + logicSections.forEach((logicSection) => { + map.set( + `${logicSection.datas.paRef?.id}+${logicSection.datas.pbRef?.id}`, + 1 + ); + }); + const axleCountings = this.app.queryStore.queryByType( + 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; + 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 (draw) { + this.draw([axleCounting, axleCountings[i]], map); + } + } + if (hasSamePosition(axleCounting, axleCountings[i])) { + hasfourTurnout.push([axleCounting, axleCountings[i]]); + } + } + }); + const fourAxleCounting: AxleCounting[] = []; + hasfourTurnout.forEach((axleCountings) => { + axleCountings.forEach((axleCounting) => { + //计轴关联的道岔 + const axleCountingRelations = + axleCounting.relationManage.getRelationsOfGraphicAndOtherType( + axleCounting, + Turnout.Type + ); + axleCountingRelations.forEach((relation) => { + const refTurnout = relation.getOtherGraphic(axleCounting); + //道岔关联的计轴 + const turnoutRelations = + refTurnout.relationManage.getRelationsOfGraphicAndOtherType( + refTurnout, + AxleCounting.Type + ); + turnoutRelations.forEach((relation) => { + const refAxleCounting = + relation.getOtherGraphic(refTurnout); + if ( + refAxleCounting.id !== axleCountings[0].id && + refAxleCounting.id !== axleCountings[1].id + ) { + fourAxleCounting.push(refAxleCounting); + } + }); + }); + }); + }); + 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].id == AxleCountings[y].id) continue; + if (fourAxleCounting[x].y == AxleCountings[y].y) { + this.draw([fourAxleCounting[x], AxleCountings[y]], map); + break; + } + } + for (let y = 0; y < 4; y++) { + if (fourAxleCounting[x + 1].id == AxleCountings[y].id) continue; + if (fourAxleCounting[x + 1].y == AxleCountings[y].y) { + this.draw([fourAxleCounting[x + 1], AxleCountings[y]], map); + break; + } + } + } + const turnouts = this.app.queryStore.queryByType(Turnout.Type); + turnouts.forEach((turnout) => { + const turnoutRelations = + turnout.relationManage.getRelationsOfGraphicAndOtherType( + turnout, + AxleCounting.Type + ); + turnoutRelations.forEach((ref) => { + const t = ref.getRelationParam(turnout); + const other = ref.getOtherGraphic(turnout) as AxleCounting; + if (t.param == 'C') { + this.draw([turnout, other], map); + } + }); + }); + } +} +class LogicSectionGraphicHitArea implements IHitArea { + logicSection: LogicSection; + constructor(logicSection: LogicSection) { + this.logicSection = logicSection; + } + contains(x: number, y: number): boolean { + for (let i = 1; i < this.logicSection.datas.points.length; i++) { + const p1 = this.logicSection.datas.points[i - 1]; + const p2 = this.logicSection.datas.points[i]; + if (linePoint(p1, p2, { x, y }, LogicSectionConsts.lineWidth)) { + return true; + } + } + return false; + } +} + +export class LogicSectionInteraction extends GraphicInteractionPlugin { + static Name = 'LogicSection_transform'; + constructor(app: JlDrawApp) { + super(LogicSectionInteraction.Name, app); + } + static init(app: JlDrawApp) { + return new LogicSectionInteraction(app); + } + filter(...grahpics: JlGraphic[]): LogicSection[] | undefined { + return grahpics + .filter((g) => g.type === LogicSection.Type) + .map((g) => g as LogicSection); + } + bind(g: LogicSection): 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 LogicSectionGraphicHitArea(g); + g.labelGraphic.eventMode = 'static'; + g.labelGraphic.cursor = 'pointer'; + g.labelGraphic.selectable = true; + g.labelGraphic.draggable = true; + } + unbind(g: LogicSection): 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; + } +} diff --git a/src/layouts/DrawLayout.vue b/src/layouts/DrawLayout.vue index 9135592..708e0c6 100644 --- a/src/layouts/DrawLayout.vue +++ b/src/layouts/DrawLayout.vue @@ -34,6 +34,9 @@ > 一键生成计轴区段 + + 一键生成逻辑区段 + @@ -201,6 +204,8 @@ import { SectionLinkDraw } from 'src/graphics/sectionLink/SectionLinkDrawAssista import { store } from 'quasar/wrappers'; import { AxleCountingSection } from 'src/graphics/axleCountingSection/AxleCountingSection'; import { AxleCountingSectionDraw } from 'src/graphics/axleCountingSection/AxleCountingSectionAssistant'; +import { LogicSection } from 'src/graphics/logicSection/LogicSection'; +import { LogicSectionDraw } from 'src/graphics/logicSection/LogicSectionDrawAssistant'; const route = useRoute(); const router = useRouter(); @@ -350,6 +355,13 @@ function oneClickAxleCountingSection() { .getDrawAssistant(AxleCountingSection.Type) as AxleCountingSectionDraw; axleCountingSectionDraw.oneGenerates(); } +function oneClickLogicSection() { + //一键生成逻辑区段 + const logicSectionDraw = drawStore + .getDrawApp() + .getDrawAssistant(LogicSection.Type) as LogicSectionDraw; + logicSectionDraw.oneGenerates(); +} function oneClickLink() { drawStore.oneClickType = 'SectionLink'; const linkList = drawStore diff --git a/src/protos/stationLayoutGraphics.ts b/src/protos/stationLayoutGraphics.ts index 17a6ae5..a73b14d 100644 --- a/src/protos/stationLayoutGraphics.ts +++ b/src/protos/stationLayoutGraphics.ts @@ -24,9 +24,10 @@ export namespace graphicData { separators?: Separator[]; sectionLinks?: SectionLink[]; axleCountingSections?: AxleCountingSection[]; + logicSections?: AxleCountingSection[]; }) { super(); - pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], this.#one_of_decls); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], this.#one_of_decls); if (!Array.isArray(data) && typeof data == "object") { if ("canvas" in data && data.canvas != undefined) { this.canvas = data.canvas; @@ -76,6 +77,9 @@ export namespace graphicData { if ("axleCountingSections" in data && data.axleCountingSections != undefined) { this.axleCountingSections = data.axleCountingSections; } + if ("logicSections" in data && data.logicSections != undefined) { + this.logicSections = data.logicSections; + } } } get canvas() { @@ -177,6 +181,12 @@ export namespace graphicData { set axleCountingSections(value: AxleCountingSection[]) { pb_1.Message.setRepeatedWrapperField(this, 16, value); } + get logicSections() { + return pb_1.Message.getRepeatedWrapperField(this, AxleCountingSection, 17) as AxleCountingSection[]; + } + set logicSections(value: AxleCountingSection[]) { + pb_1.Message.setRepeatedWrapperField(this, 17, value); + } static fromObject(data: { canvas?: ReturnType; links?: ReturnType[]; @@ -194,6 +204,7 @@ export namespace graphicData { separators?: ReturnType[]; sectionLinks?: ReturnType[]; axleCountingSections?: ReturnType[]; + logicSections?: ReturnType[]; }): RtssGraphicStorage { const message = new RtssGraphicStorage({}); if (data.canvas != null) { @@ -244,6 +255,9 @@ export namespace graphicData { if (data.axleCountingSections != null) { message.axleCountingSections = data.axleCountingSections.map(item => AxleCountingSection.fromObject(item)); } + if (data.logicSections != null) { + message.logicSections = data.logicSections.map(item => AxleCountingSection.fromObject(item)); + } return message; } toObject() { @@ -264,6 +278,7 @@ export namespace graphicData { separators?: ReturnType[]; sectionLinks?: ReturnType[]; axleCountingSections?: ReturnType[]; + logicSections?: ReturnType[]; } = {}; if (this.canvas != null) { data.canvas = this.canvas.toObject(); @@ -313,6 +328,9 @@ export namespace graphicData { if (this.axleCountingSections != null) { data.axleCountingSections = this.axleCountingSections.map((item: AxleCountingSection) => item.toObject()); } + if (this.logicSections != null) { + data.logicSections = this.logicSections.map((item: AxleCountingSection) => item.toObject()); + } return data; } serialize(): Uint8Array; @@ -351,6 +369,8 @@ export namespace graphicData { writer.writeRepeatedMessage(15, this.sectionLinks, (item: SectionLink) => item.serialize(writer)); if (this.axleCountingSections.length) writer.writeRepeatedMessage(16, this.axleCountingSections, (item: AxleCountingSection) => item.serialize(writer)); + if (this.logicSections.length) + writer.writeRepeatedMessage(17, this.logicSections, (item: AxleCountingSection) => item.serialize(writer)); if (!w) return writer.getResultBuffer(); } @@ -408,6 +428,9 @@ export namespace graphicData { case 16: reader.readMessage(message.axleCountingSections, () => pb_1.Message.addToRepeatedWrapperField(message, 16, AxleCountingSection.deserialize(reader), AxleCountingSection)); break; + case 17: + reader.readMessage(message.logicSections, () => pb_1.Message.addToRepeatedWrapperField(message, 17, AxleCountingSection.deserialize(reader), AxleCountingSection)); + break; default: reader.skipField(); } }