Showing 271 of 665 total issues
Function widgetsBase
has 334 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsBase = (three = (window as any).THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
Function widgetsAnnotation
has 312 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsAnnotation = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
Function widgetsAngle
has 310 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsAngle = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
Function presetLuts
has 303 lines of code (exceeds 25 allowed). Consider refactoring. Open
static presetLuts() {
return {
default: [[0, 0, 0, 0], [1, 1, 1, 1]],
spectrum: [
[0, 0, 0, 0],
Function widgetsVelocityTimeIntegral
has a Cognitive Complexity of 70 (exceeds 5 allowed). Consider refactoring. Open
const widgetsVelocityTimeIntegral = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsRuler
has 272 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsRuler = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
ParsersDicom
has 72 functions (exceeds 20 allowed). Consider refactoring. Open
export default class ParsersDicom extends ParsersVolume {
constructor(data, id) {
super();
this._id = id;
Function presetLutsO
has 266 lines of code (exceeds 25 allowed). Consider refactoring. Open
static presetLutsO() {
return {
linear: [[0, 0], [1, 1]],
lowpass: [[0, 0.8], [0.2, 0.6], [0.3, 0.1], [1, 0]],
bandpass: [[0, 0], [0.4, 0.8], [0.6, 0.8], [1, 0]],
ModelsFrame
has 71 functions (exceeds 20 allowed). Consider refactoring. Open
export default class ModelsFrame extends ModelsBase {
/**
* Constructor
*/
constructor() {
Function widgetsBiruler
has a Cognitive Complexity of 64 (exceeds 5 allowed). Consider refactoring. Open
const widgetsBiruler = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsBase
has a Cognitive Complexity of 64 (exceeds 5 allowed). Consider refactoring. Open
const widgetsBase = (three = (window as any).THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsEllipse
has a Cognitive Complexity of 62 (exceeds 5 allowed). Consider refactoring. Open
const widgetsEllipse = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function helpersStack
has 242 lines of code (exceeds 25 allowed). Consider refactoring. Open
const helpersStack = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
Function widgetsHandle
has 234 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsHandle = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
Function helpersSlice
has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring. Open
const helpersSlice = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsPressureHalfTime
has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring. Open
const widgetsPressureHalfTime = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsHandle
has a Cognitive Complexity of 56 (exceeds 5 allowed). Consider refactoring. Open
const widgetsHandle = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function widgetsPeakVelocity
has 213 lines of code (exceeds 25 allowed). Consider refactoring. Open
const widgetsPeakVelocity = (three = window.THREE) => {
if (three === undefined || three.Object3D === undefined) {
return null;
}
File cameras.orthographic.js
has 513 lines of code (exceeds 250 allowed). Consider refactoring. Open
import Intersections from '../core/core.intersections';
import Validators from '../core/core.validators';
/**
* Orthographic camera from THREE.JS with some extra convenience
File widgets.velocityTimeIntegral.js
has 504 lines of code (exceeds 250 allowed). Consider refactoring. Open
import { widgetsBase } from './widgets.base';
import { widgetsHandle as widgetsHandleFactory } from './widgets.handle';
import CoreUtils from '../core/core.utils';
/**