codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/util/algorithm/streetLayout/boundingBox.ts

@@ -1,25 +0,0 @@
-import { Vector2 } from "three"
-import { CodeMapNode } from "../../../codeCharta.model"
-import Rectangle from "./rectangle"
-
-export default abstract class BoundingBox {
-	height = 0
-	width = 0
-	protected node: CodeMapNode
-	protected metricValue: number
-	protected FIXED_MARGIN = 0.5
-
-	constructor(node: CodeMapNode) {
-		this.node = node
-	}
-
-	abstract calculateDimension(metricName: string): void
-	abstract layout(margin: number, origin: Vector2): CodeMapNode[]
-
-	protected createMarginatedRectangle(origin: Vector2) {
-		const newOrigin = new Vector2(origin.x + this.FIXED_MARGIN, origin.y + this.FIXED_MARGIN)
-		const width = this.width - 2 * this.FIXED_MARGIN
-		const height = this.height - 2 * this.FIXED_MARGIN
-		return new Rectangle(newOrigin, width, height)
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/horizontalStreet.spec.ts

@@ -1,36 +0,0 @@
-import { CodeMapNode } from "../../../codeCharta.model"
-import { klona } from "klona"
-import { VALID_NODE_WITH_PATH } from "../../dataMocks"
-import HorizontalStreet, { HorizontalOrientation } from "./horizontalStreet"
-import BoundingBox from "./boundingBox"
-import House from "./house"
-import { Vector2 } from "three"
-
-describe("horizontalStreet", () => {
-	let codeMapNode: CodeMapNode
-	let horizontalStreet: HorizontalStreet
-	let children: BoundingBox[]
-	let house: House
-	beforeEach(() => {
-		codeMapNode = klona(VALID_NODE_WITH_PATH)
-		codeMapNode.path = "somePath"
-		house = new House(codeMapNode)
-		children = [house]
-		horizontalStreet = new HorizontalStreet(codeMapNode, children, 1, HorizontalOrientation.RIGHT)
-	})
-	describe("calculateDimension", () => {
-		it("should calculate street width and height", () => {
-			horizontalStreet["getLength"] = jest.fn()
-			horizontalStreet.calculateDimension("mcc")
-			expect(horizontalStreet.width).toEqual(Math.max(horizontalStreet["getLength"]([]), horizontalStreet["getLength"]([])))
-		})
-	})
-
-	describe("layout", () => {
-		it("should not call calculateStreetOverhang", () => {
-			horizontalStreet["calculateStreetOverhang"] = jest.fn()
-			horizontalStreet.layout(1, new Vector2(2, 3))
-			expect(horizontalStreet["calculateStreetOverhang"]).toHaveBeenCalled()
-		})
-	})
-})

package/app/codeCharta/util/algorithm/streetLayout/horizontalStreet.ts

@@ -1,252 +0,0 @@
-import Street from "./street"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { Vector2 } from "three"
-import Rectangle from "./rectangle"
-import VerticalStreet, { VerticalOrientation } from "./verticalStreet"
-import BoundingBox from "./boundingBox"
-import { StreetViewHelper } from "./streetViewHelper"
-
-export enum HorizontalOrientation {
-	RIGHT,
-	LEFT
-}
-
-export default class HorizontalStreet extends Street {
-	private children: BoundingBox[] = []
-	protected node: CodeMapNode
-	protected topRow: BoundingBox[] = []
-	protected bottomRow: BoundingBox[] = []
-	orientation: HorizontalOrientation
-	protected depth: number
-
-	constructor(
-		node: CodeMapNode,
-		children: BoundingBox[],
-		depth: number,
-		orientation: HorizontalOrientation = HorizontalOrientation.RIGHT
-	) {
-		super(node)
-		this.children = children
-		this.depth = depth
-		this.orientation = orientation
-	}
-
-	calculateDimension(metricName: string): void {
-		// calculates street width and height
-		for (const child of this.children) {
-			child.calculateDimension(metricName)
-		}
-
-		// splits the children in top and bottom side of the street
-		this.splitChildrenToRows(this.children)
-
-		// note : longest street will be last in the row
-		this.rearrangeRows()
-
-		// TODO Add a comment what the following calculations are doing.
-		this.metricValue = StreetViewHelper.calculateSize(this.node, metricName)
-		this.width = Math.max(this.getLength(this.topRow), this.getLength(this.bottomRow))
-		this.height = this.getMaxHeight(this.topRow) + this.getStreetThickness() + this.getMaxHeight(this.bottomRow) + 2 * this.spacer
-	}
-
-	layout(margin: number, origin: Vector2): CodeMapNode[] {
-		const maxTopHeight = this.getMaxHeight(this.topRow)
-		const topRowNodes = this.layoutTopRow(origin, maxTopHeight, margin)
-		const bottomRowNodes = this.layoutBottomRow(origin, maxTopHeight, margin)
-		const streetNode = this.layoutStreet(origin, maxTopHeight)
-
-		return [...topRowNodes, streetNode, ...bottomRowNodes]
-	}
-
-	private layoutTopRow(origin: Vector2, maxTopHeight: number, margin: number): CodeMapNode[] {
-		const rowOrigin = new Vector2(origin.x, origin.y)
-		const nodes: CodeMapNode[] = []
-
-		if (this.orientation === HorizontalOrientation.LEFT) {
-			const rowWidth = this.getLength(this.topRow)
-			rowOrigin.x += this.width - rowWidth
-		}
-		for (let index = 0; index < this.topRow.length; index++) {
-			const childOriginX = this.calculateChildOriginX(rowOrigin, index, this.topRow)
-			const childOriginY = this.calculateStreetOffsetY(rowOrigin, maxTopHeight) - this.topRow[index].height
-			const childOrigin = new Vector2(childOriginX, childOriginY)
-			nodes.push(...this.topRow[index].layout(margin, childOrigin))
-		}
-		return nodes
-	}
-
-	/**
-	 * Creates the layout for the street node.
-	 * @param origin origin of local coordinate system
-	 * @param maxTopHeight highest node in top row
-	 */
-	protected layoutStreet(origin: Vector2, maxTopHeight: number): CodeMapNode {
-		const streetOffsetY = this.calculateStreetOffsetY(origin, maxTopHeight)
-		const streetOrigin = new Vector2(origin.x, streetOffsetY)
-		const streetOverhang = this.calculateStreetOverhang(streetOrigin)
-		const streetWidth = this.width - streetOverhang
-
-		streetOrigin.x += this.orientation === HorizontalOrientation.LEFT ? streetOverhang : 0
-		this.streetRect = new Rectangle(streetOrigin, streetWidth, this.getStreetThickness())
-
-		return {
-			...this.node,
-			value: this.metricValue,
-			rect: this.streetRect,
-			zOffset: 0
-		} as CodeMapNode
-	}
-
-	/**
-	 * Creates the layout for the bottomRow.
-	 * @param origin origin of local coordinate system
-	 * @param maxTopHeight highest node in top row
-	 */
-	private layoutBottomRow(origin: Vector2, maxTopHeight: number, margin: number): CodeMapNode[] {
-		const rowOrigin = new Vector2(origin.x, origin.y)
-		const nodes: CodeMapNode[] = []
-
-		if (this.orientation === HorizontalOrientation.LEFT) {
-			const rowWidth = this.getLength(this.bottomRow)
-			rowOrigin.x += this.width - rowWidth
-		}
-		for (let index = 0; index < this.bottomRow.length; index++) {
-			const childOriginX = this.calculateChildOriginX(rowOrigin, index, this.bottomRow)
-			const childOriginY = this.calculateStreetOffsetY(rowOrigin, maxTopHeight) + this.getStreetThickness()
-			const childOrigin = new Vector2(childOriginX, childOriginY)
-			nodes.push(...this.bottomRow[index].layout(margin, childOrigin))
-		}
-		return nodes
-	}
-
-	/**
-	 * Calculates x-coordinate of current child
-	 * @param origin origin of local coordinate system
-	 * @param index index in row of current node
-	 * @param row the node's row
-	 */
-	private calculateChildOriginX(origin: Vector2, index: number, row: BoundingBox[]): number {
-		return origin.x + this.getLengthUntil(row, index)
-	}
-
-	/**
-	 * Calculates y-coordinate of street.
-	 * @param origin origin of local coordinate system
-	 * @param maxLeftWidth highest node in topRow
-	 */
-	private calculateStreetOffsetY(origin: Vector2, maxTopHeight: number): number {
-		return origin.y + this.spacer + maxTopHeight
-	}
-
-	/**
-	 * Gets total length of the street.
-	 * @param boxes placed boxes
-	 */
-	private getLength(boxes: BoundingBox[]): number {
-		return this.getLengthUntil(boxes, boxes.length)
-	}
-
-	/**
-	 * Gets length of street from start to end index.
-	 * @param boxes placed boxes
-	 * @param end end index
-	 */
-	private getLengthUntil(boxes: BoundingBox[], end: number): number {
-		let sum = 0
-
-		for (let index = 0; index < end; index++) {
-			sum += boxes[index].width
-		}
-		return sum
-	}
-
-	/**
-	 * Divides children nodes into top- and bottomrow
-	 * @param children children of the current node
-	 */
-	protected splitChildrenToRows(children: BoundingBox[]): void {
-		const totalLength = this.getLength(children)
-		let sum = 0
-
-		for (const child of children) {
-			if (sum < totalLength / 2) {
-				this.topRow.push(child)
-				sum += child.width
-			} else {
-				if (child instanceof VerticalStreet) {
-					child.orientation = VerticalOrientation.DOWN
-				}
-				this.bottomRow.push(child)
-			}
-		}
-	}
-
-	/**
-	 * Arranges rows according to their orientation
-	 */
-	protected rearrangeRows(): void {
-		if (this.orientation === HorizontalOrientation.RIGHT) {
-			this.bottomRow.reverse()
-		} else {
-			this.topRow.reverse()
-		}
-	}
-
-	/**
-	 * Gets the highest box of an array of boxes.
-	 * @param boxes boxes to be checked
-	 */
-	private getMaxHeight(boxes: BoundingBox[]): number {
-		return boxes.reduce((max, n) => Math.max(max, n.height), Number.MIN_VALUE)
-	}
-
-	/**
-	 * Calculates overhang of a street.
-	 * @param streetOrigin topleft point of street
-	 */
-	protected calculateStreetOverhang(streetOrigin: Vector2): number {
-		if (this.orientation === HorizontalOrientation.LEFT) {
-			return this.calculateLeftStreetOverhang(streetOrigin)
-		}
-		return this.calculateRightStreetOverhang(streetOrigin)
-	}
-
-	/**
-	 * Calculates left hand side overhang of a street.
-	 * @param streetOrigin topleft point of street
-	 */
-	private calculateLeftStreetOverhang(streetOrigin: Vector2): number {
-		const firstTopBox = this.topRow[0]
-		const firstBottomBox = this.bottomRow[0]
-		const topOverhang =
-			firstTopBox instanceof VerticalStreet && firstTopBox.streetRect
-				? firstTopBox.streetRect.topLeft.x - streetOrigin.x
-				: this.width - this.getLength(this.topRow)
-		const bottomOverhang =
-			firstBottomBox instanceof VerticalStreet && firstBottomBox.streetRect
-				? firstBottomBox.streetRect.topLeft.x - streetOrigin.x
-				: this.width - this.getLength(this.bottomRow)
-
-		return topOverhang > 0 && bottomOverhang > 0 ? Math.min(topOverhang, bottomOverhang) : 0
-	}
-
-	/**
-	 * Calculates right hand side overhang of a street.
-	 * @param streetOrigin topleft point of street
-	 */
-	private calculateRightStreetOverhang(streetOrigin: Vector2): number {
-		const lastTopBox = this.topRow.at(-1)
-		const lastBottomBox = this.bottomRow.at(-1)
-		const streetRightX = streetOrigin.x + this.width
-		const topOverhang =
-			lastTopBox instanceof VerticalStreet && lastTopBox.streetRect
-				? streetRightX - lastTopBox.streetRect.getBottomRight().x
-				: this.width - this.getLength(this.topRow)
-		const bottomOverhang =
-			lastBottomBox instanceof VerticalStreet && lastBottomBox.streetRect
-				? streetRightX - lastBottomBox.streetRect.getBottomRight().x
-				: this.width - this.getLength(this.bottomRow)
-
-		return topOverhang > 0 && bottomOverhang > 0 ? Math.min(topOverhang, bottomOverhang) : 0
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/house.spec.ts

@@ -1,26 +0,0 @@
-import { CodeMapNode } from "../../../codeCharta.model"
-import { klona } from "klona"
-import { VALID_NODE_WITH_PATH } from "../../dataMocks"
-import House from "./house"
-import { Vector2 } from "three"
-
-describe("house", () => {
-	let codeMapNode: CodeMapNode
-	let house: House
-	beforeEach(() => {
-		codeMapNode = klona(VALID_NODE_WITH_PATH)
-		codeMapNode.path = "somePath"
-		house = new House(codeMapNode)
-	})
-	describe("layout", () => {
-		it("should return array of layoutNode", () => {
-			const layoutNode: CodeMapNode = {
-				...house["node"],
-				value: house["metricValue"],
-				rect: house["createMarginatedRectangle"](new Vector2(2, 3)),
-				zOffset: 0
-			}
-			expect(house.layout(1, new Vector2(2, 3))).toEqual([layoutNode])
-		})
-	})
-})

package/app/codeCharta/util/algorithm/streetLayout/house.ts

@@ -1,26 +0,0 @@
-import BoundingBox from "./boundingBox"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { Vector2 } from "three"
-import { StreetViewHelper } from "./streetViewHelper"
-
-export default class House extends BoundingBox {
-	constructor(node: CodeMapNode) {
-		super(node)
-	}
-
-	calculateDimension(metricName: string): void {
-		this.metricValue = StreetViewHelper.calculateSize(this.node, metricName)
-		const size = Math.sqrt(this.metricValue)
-		this.width = this.height = size
-	}
-
-	layout(_, origin: Vector2): CodeMapNode[] {
-		const layoutNode: CodeMapNode = {
-			...this.node,
-			value: this.metricValue,
-			rect: this.createMarginatedRectangle(origin),
-			zOffset: 0
-		}
-		return [layoutNode]
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/rectangle.spec.ts

@@ -1,43 +0,0 @@
-import { Vector2 } from "three"
-import Rectangle from "./rectangle"
-
-describe("Rectangle", () => {
-	let rectangle1, rectangle2: Rectangle
-
-	beforeEach(() => {
-		rectangle1 = new Rectangle(new Vector2(2, 2), 8, 13)
-		rectangle2 = new Rectangle(new Vector2(2, 2), 13, 8)
-	})
-	describe("shorterSide", () => {
-		it("should return width when height is longer then width", () => {
-			expect(rectangle1.shorterSide()).toBe(8)
-		})
-
-		it("should return height when width is longer then height", () => {
-			expect(rectangle2.shorterSide()).toBe(8)
-		})
-	})
-
-	describe("isVertical", () => {
-		it("should return true when height is longer then width", () => {
-			expect(rectangle1.isVertical()).toBeTruthy()
-		})
-
-		it("should return false when width is longer then height", () => {
-			expect(rectangle2.isVertical()).toBeFalsy()
-		})
-	})
-
-	describe("area", () => {
-		it("should return correct area", () => {
-			expect(rectangle1.area()).toBe(8 * 13)
-		})
-	})
-
-	describe("getBottomRight", () => {
-		it("should return bottom Position", () => {
-			expect(rectangle1.getBottomRight().x).toBe(10)
-			expect(rectangle1.getBottomRight().y).toBe(15)
-		})
-	})
-})

package/app/codeCharta/util/algorithm/streetLayout/rectangle.ts

@@ -1,32 +0,0 @@
-import { Vector2 } from "three"
-
-export default class Rectangle {
-	topLeft: Vector2
-	width: number
-	height: number
-	private bottomRight: Vector2
-
-	constructor(topLeft: Vector2, width: number, height: number) {
-		this.topLeft = topLeft
-		this.bottomRight = topLeft.clone().add(new Vector2(width, height))
-		this.width = width
-		this.height = height
-	}
-
-	// TODO rename
-	shorterSide(): number {
-		return this.width > this.height ? this.height : this.width
-	}
-
-	isVertical(): boolean {
-		return this.height > this.width
-	}
-
-	area(): number {
-		return this.width * this.height
-	}
-
-	getBottomRight(): Vector2 {
-		return this.bottomRight
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/squarifiedTreeMap.ts

@@ -1,112 +0,0 @@
-import Treemap from "./treeMap"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { Vector2 } from "three"
-import Rectangle from "./rectangle"
-import HorizontalStrip from "./strip/horizontalStrip"
-import VerticalStrip from "./strip/verticalStrip"
-import Strip from "./strip/strip"
-import { TreeMapHelper } from "../treeMapLayout/treeMapHelper"
-
-export default class SquarifiedTreeMap extends Treemap {
-	constructor(rootNode: CodeMapNode) {
-		super(rootNode)
-	}
-
-	layout(margin: number, origin: Vector2 = new Vector2(0, 0)): CodeMapNode[] {
-		const rectangle = this.createMarginatedRectangle(origin)
-		const rootNode: CodeMapNode = {
-			...this.node,
-			value: this.metricValue,
-			rect: rectangle,
-			zOffset: 0
-		}
-		const children = this.node.children.filter(child => TreeMapHelper.calculateSize(child, this.metricName) > 0)
-
-		this.treeMapNodes.push(rootNode)
-
-		if (children.length > 0) {
-			this.createNodes(children, rectangle, this.metricValue, 1, margin)
-		}
-
-		return this.treeMapNodes
-	}
-
-	protected createNodes(nodes: CodeMapNode[], rect: Rectangle, rootSize: number, currentTreemapDepth: number, margin: number): void {
-		let processedNodesCount = 0
-		let currentRect = new Rectangle(new Vector2(rect.topLeft.x, rect.topLeft.y), rect.width, rect.height)
-		let currentRootSize = rootSize
-		const orderedNodes = this.orderBySizeDescending(nodes)
-
-		do {
-			const currentStrip = this.createStrip(currentRect, orderedNodes.slice(processedNodesCount), currentRootSize)
-			const stripSize = currentStrip.totalSize(this.metricName)
-
-			if (stripSize > 0) {
-				const stripNodes = this.createStripNodes(currentStrip, currentRect, currentRootSize, currentTreemapDepth, margin)
-				this.createChildrenNodes(stripNodes, currentTreemapDepth, margin)
-				currentRect = this.remainingRectangle(currentRect, currentStrip, currentRootSize, currentRect.area())
-				currentRootSize -= stripSize
-			}
-			processedNodesCount += currentStrip.nodes.length
-		} while (processedNodesCount < orderedNodes.length) /* as long as there are children to process */
-	}
-
-	protected createStrip(rect: Rectangle, nodes: CodeMapNode[], rootSize: number): Strip {
-		const firstNode = nodes[0]
-		const currentStrip = rect.isVertical() ? new HorizontalStrip([firstNode]) : new VerticalStrip([firstNode])
-
-		currentStrip.populate(nodes.slice(1), rect, rootSize, this.metricName)
-
-		return currentStrip
-	}
-
-	protected remainingRectangle(rect: Rectangle, strip: Strip, parentSize: number, parentArea: number): Rectangle {
-		const stripSize = strip.totalScaledSize(strip.nodes, this.metricName, parentSize, parentArea)
-
-		let newOrigin: Vector2
-		let width = rect.width
-		let height = rect.height
-
-		if (strip instanceof HorizontalStrip) {
-			const stripHeight = stripSize / rect.width
-			height -= stripHeight
-			newOrigin = new Vector2(rect.topLeft.x, rect.topLeft.y + stripHeight)
-		} else {
-			const stripWidth = stripSize / rect.height
-			width -= stripWidth
-			newOrigin = new Vector2(rect.topLeft.x + stripWidth, rect.topLeft.y)
-		}
-		return new Rectangle(newOrigin, width, height)
-	}
-
-	protected createStripNodes(
-		strip: Strip,
-		rect: Rectangle,
-		rootSize: number,
-		currentTreemapDepth: number,
-		margin: number,
-		order?: number
-	): CodeMapNode[] {
-		const stripNodes = strip.layout(rect, rootSize, this.metricName, currentTreemapDepth, margin, order)
-		this.treeMapNodes.push(...stripNodes)
-		return stripNodes
-	}
-
-	protected createChildrenNodes(stripNodes: CodeMapNode[], currentTreemapDepth: number, margin: number): void {
-		for (const node of stripNodes) {
-			if (node.children && node.children.length > 0) {
-				const children = node.children.filter(child => TreeMapHelper.calculateSize(child, this.metricName) > 0)
-				if (children.length > 0) {
-					const size = TreeMapHelper.calculateSize(node, this.metricName)
-					this.createNodes(children, node.rect, size, currentTreemapDepth + 1, margin)
-				}
-			}
-		}
-	}
-
-	private orderBySizeDescending(nodes: CodeMapNode[]): CodeMapNode[] {
-		return nodes.sort((a, b) => {
-			return TreeMapHelper.calculateSize(b, this.metricName) - TreeMapHelper.calculateSize(a, this.metricName)
-		})
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/street.ts

@@ -1,25 +0,0 @@
-import BoundingBox from "./boundingBox"
-import Rectangle from "./rectangle"
-import { Vector2 } from "three"
-import { CodeMapNode } from "../../../codeCharta.model"
-
-export enum StreetOrientation {
-	Horizontal,
-	Vertical
-}
-
-export default abstract class Street extends BoundingBox {
-	streetRect: Rectangle | undefined
-	protected spacer = 2
-	private maxStreetThickness = 10
-	protected abstract depth: number
-
-	protected abstract layoutStreet(origin: Vector2, maxNodeSideLength: number): CodeMapNode
-	protected abstract splitChildrenToRows(children: BoundingBox[]): void
-	protected abstract calculateStreetOverhang(streetOrigin: Vector2): number
-	protected abstract rearrangeRows(): void
-
-	protected getStreetThickness(): number {
-		return this.maxStreetThickness / (this.depth + 1)
-	}
-}

package/app/codeCharta/util/algorithm/streetLayout/streetLayoutGenerator.spec.ts

@@ -1,24 +0,0 @@
-import { StreetLayoutGenerator } from "./streetLayoutGenerator"
-import { CodeMapNode, LayoutAlgorithm } from "../../../codeCharta.model"
-import { klona } from "klona"
-import { METRIC_DATA, STATE, VALID_NODE_WITH_PATH } from "../../dataMocks"
-
-describe("horizontalStreet", () => {
-	let codeMapNode: CodeMapNode
-	beforeEach(() => {
-		codeMapNode = klona(VALID_NODE_WITH_PATH)
-		codeMapNode.path = "somePath"
-	})
-	describe("createStreetLayoutNodes", () => {
-		it("should not call createTreeMap", () => {
-			StreetLayoutGenerator.createStreetLayoutNodes(codeMapNode, STATE, METRIC_DATA, false)
-			expect(StreetLayoutGenerator.createStreetLayoutNodes).toBeTruthy()
-		})
-
-		it("should call createTreeMap", () => {
-			STATE.appSettings.layoutAlgorithm = LayoutAlgorithm.TreeMapStreet
-			StreetLayoutGenerator.createStreetLayoutNodes(codeMapNode, STATE, METRIC_DATA, false)
-			expect(StreetLayoutGenerator.createStreetLayoutNodes).toBeTruthy()
-		})
-	})
-})