Skip to content

tooth loaction

Great! Since you're using the (-1, 0, 1) coordinate system, I'll provide a detailed explanation and implementation for this system. This system is centered at zero, making it ideal for representing physical systems, symmetry, and 3D visualization.

2. Unique Number Derivation

To derive a unique number for each point in the 3x3x3 grid, we use the following formula: 

uniqueNumber = (x + 1) * 9 + (y + 1) * 3 + (z + 1) + 1

Explanation of the Formula:

  1. (x + 1):
  2. Converts x from {-1, 0, 1} to {0, 1, 2}.

  3. This ensures that the indices are non-negative.

  4. (y + 1):

  5. Converts y from {-1, 0, 1} to {0, 1, 2}.

  6. (z + 1):

  7. Converts z from {-1, 0, 1} to {0, 1, 2}.

  8. * 9, * 3, and + 1:

  9. These weights ensure that each combination of (x, y, z) maps to a unique number between 1 and 27.

3. Full Mapping of Unique Numbers

Here’s the full mapping of unique numbers for all 27 points:

Coordinates (x, y, z) Unique Number
(-1, -1, -1) 1
(-1, -1, 0) 2
(-1, -1, 1) 3
(-1, 0, -1) 4
(-1, 0, 0) 5
(-1, 0, 1) 6
(-1, 1, -1) 7
(-1, 1, 0) 8
(-1, 1, 1) 9
(0, -1, -1) 10
(0, -1, 0) 11
(0, -1, 1) 12
(0, 0, -1) 13
(0, 0, 0) 14
(0, 0, 1) 15
(0, 1, -1) 16
(0, 1, 0) 17
(0, 1, 1) 18
(1, -1, -1) 19
(1, -1, 0) 20
(1, -1, 1) 21
(1, 0, -1) 22
(1, 0, 0) 23
(1, 0, 1) 24
(1, 1, -1) 25
(1, 1, 0) 26
(1, 1, 1) 27

4. Implementation in Code

Here’s the updated code for the (-1, 0, 1) coordinate system:

Open 3D Scatter Plot

5. Output

  1. 3D Scatter Plot:
  2. A 3D scatter plot with 27 points arranged in a 3x3x3 grid, centered at (0, 0, 0).

  3. Users can zoom in/out, rotate, and pan the plot.

  4. Table:

  5. A table displaying the derived unique number, coordinates, and flattened index for each of the 27 points.

area

Teeth numbering system is present then why not tooth numbering system to locate affected areas

tooth is dovided into thirds

image

A 3×3×3 cube has 27 pieces in total, but they are categorized based on their position:

📌 Types of Pieces in a 3×3×3 Cube:

Center Pieces (6 total) Each face has one center piece (they don’t move). Always stay in the same position relative to each other.

Edge Pieces (12 total) Each edge piece connects two faces. These have two colors each.

Corner Pieces (8 total) Each corner piece connects three faces. These have three colors each.

1 is excluded due to gingival attachment

27-1 = 26 areas

starting from center

Thank you for the clarification! If single z = 1 should also be classified as pit and fissure, I've updated the logic accordingly. Here's the corrected implementation:

Key Changes:

  1. Area Classification:
  2. Cervical: z === -1 (near the gum line).
  3. Proximal: y === 1 or y === -1 (near adjacent teeth).
  4. Pit and Fissure: x === 1, x === -1, or z === 1 (on the occlusal surface or single z = 1).

  5. Smooth Surface: All other cases (buccal, lingual, mesial, or distal surfaces).

  6. Priority Rules:

  7. z has the highest priority, followed by y, and then x.
  8. If z is non-zero, it takes precedence over y and x.

  9. If y is non-zero, it takes precedence over x.

  10. Corner, Edge, and Mid Classification:

  11. Corner: All three coordinates are either 1 or -1.
  12. Edge: Two coordinates are either 1 or -1.
  13. Mid: Only one coordinate is either 1 or -1.

Here’s the updated code:

Explanation of Changes:

  1. Area Classification:
  2. Cervical: Assigned when z === -1.
  3. Proximal: Assigned when y === 1 or y === -1.
  4. Pit and Fissure: Assigned when x === 1, x === -1, or z === 1.

  5. Smooth Surface: Assigned for all other cases.

  6. Priority Rules:

  7. z is checked first, followed by y, and then x.

  8. Category Classification:

  9. Corner: All three coordinates are non-zero.
  10. Edge: Two coordinates are non-zero.
  11. Mid: One coordinate is non-zero.
  12. Center: All coordinates are zero.

This implementation now correctly classifies single z = 1 as pit and fissure. Let me know if you need further adjustments!

The unique number for each point is derived based on its position in the 3D grid defined by the nested loops (i, j, k). Here's the breakdown of how it works:

Formula for Unique Number:

The unique number is calculated using the formula: 

let uniqueNumber = i * 9 + j * 3 + k + 1;

Explanation:

  1. Grid Dimensions:
  2. The grid is a 3x3x3 cube, so each coordinate (i, j, k) ranges from 0 to 2.

  3. There are a total of 3 * 3 * 3 = 27 points in the grid.

  4. Derivation:

  5. i represents the x-axis layer (0, 1, 2).
  6. j represents the y-axis layer (0, 1, 2).
  7. k represents the z-axis layer (0, 1, 2).

The formula i * 9 + j * 3 + k + 1 ensures that each point gets a unique number between 1 and 27: - i * 9: Each x-axis layer (i) contributes 9 unique numbers (since there are 3 * 3 = 9 points per layer). - j * 3: Each y-axis row (j) within a layer contributes 3 unique numbers. - k: Each z-axis point (k) within a row contributes 1 unique number. - + 1: Ensures the numbering starts from 1 instead of 0.

Example:

For a point at (i = 1, j = 2, k = 0): 

let uniqueNumber = 1 * 9 + 2 * 3 + 0 + 1; // 9 + 6 + 0 + 1 = 16
So, the unique number for this point is 16.

Visualization of Unique Numbers:

Here’s how the unique numbers are assigned for each point in the 3D grid:

i (x-axis) j (y-axis) k (z-axis) Unique Number
0 0 0 1
0 0 1 2
0 0 2 3
0 1 0 4
0 1 1 5
0 1

You're absolutely correct! If the coordinates (xCoord, yCoord, zCoord) only take values -1, 0, or 1, then the grid is a 3x3x3 cube centered at the origin, and the unique number derivation should be adjusted accordingly. Let me explain how to derive the unique number in this case.

Updated Formula for Unique Number:

Since the coordinates are derived as: 

let xCoord = i - 1; // i = 0, 1, 2 → xCoord = -1, 0, 1
let yCoord = j - 1; // j = 0, 1, 2 → yCoord = -1, 0, 1
let zCoord = k - 1; // k = 0, 1, 2 → zCoord = -1, 0, 1

The unique number can still be derived using the formula: 

let uniqueNumber = i * 9 + j * 3 + k + 1;

Why This Formula Works:

  1. Grid Structure:
  2. The grid is a 3x3x3 cube with coordinates ranging from -1 to 1 along each axis.

  3. Each point is uniquely identified by its (i, j, k) indices, where i, j, and k range from 0 to 2.

  4. Mapping Indices to Unique Numbers:

  5. The formula i * 9 + j * 3 + k + 1 maps each (i, j, k) combination to a unique number between 1 and 27. ** - This works because**:

    • Each i value (0, 1, 2) represents a "layer" along the x-axis, and each layer contains 9 points (3 * 3).
    • Each j value (0, 1, 2) represents a "row" within a layer, and each row contains 3 points.
    • Each k value (0, 1, 2) represents a specific point within a row.

  6. Example:

  7. For (i = 1, j = 2, k = 0): 
    let uniqueNumber = 1 * 9 + 2 * 3 + 0 + 1; // 9 + 6 + 0 + 1 = 16
    This corresponds to the point (xCoord = 0, yCoord = 1, zCoord = -1).

Why Not Use xCoord, yCoord, zCoord Directly?

The coordinates (xCoord, yCoord, zCoord) are centered around 0 and range from -1 to 1. However, they are not directly suitable for deriving a unique number because: - They include negative values (-1), which complicate indexing. - They are not sequential (e.g., -1, 0, 1), so a direct mapping would require additional logic.

Instead, the indices (i, j, k) are used because they are sequential (0, 1, 2) and can easily be mapped to a unique number using the formula.

Full Mapping of Unique Numbers:

Here’s the complete mapping of (i, j, k) to (xCoord, yCoord, zCoord) and the corresponding unique number:

i j k xCoord yCoord zCoord Unique Number
0 0 0 -1 -1 -1 1
0 0 1 -1 -1 0 2
0 0 2 -1 -1 1 3
0 1 0 -1 0 -1 4
0 1 1 -1 0 0 5
0 1 2 -1 0 1 6
0 2 0 -1 1 -1 7
0 2 1 -1 1 0 8
0 2 2 -1 1 1 9
1 0 0 0 -1 -1 10
1 0 1 0 -1 0 11
1 0 2 0 -1 1 12
1 1 0 0 0 -1 13
1 1 1 0 0 0 14
1 1 2 0 0 1 15
1 2 0 0 1 -1 16
1 2 1 0 1 0 17
1 2 2 0 1 1 18
2 0 0 1 -1 -1 19
2 0 1 1 -1 0 20
2 0 2 1 -1 1 21
2 1 0 1 0 -1 22
2 1 1 1 0 0 23
2 1 2 1 0 1 24
2 2 0 1 1 -1 25
2 2 1 1 1 0 26
2 2 2 1 1 1 27

Why This Works for -1, 0, 1:

The formula i * 9 + j * 3 + k + 1 works because: - It treats the 3D grid as a flattened 1D array. - It ensures that each (i, j, k) combination maps to a unique number between 1 and 27. - It doesn't depend on the actual coordinate values (-1, 0, 1) but rather on their indices (i, j, k).

Alternative Approach:

If you want to derive the unique number directly from (xCoord, yCoord, zCoord), you can use the following formula: 

let uniqueNumber = (xCoord + 1) * 9 + (yCoord + 1) * 3 + (zCoord + 1) + 1;

This formula shifts the coordinates from (-1, 0, 1) to (0, 1, 2) and then applies the same logic as before.

Let me know if you need further clarification or adjustments! 😊

To map the unique number back to its corresponding axis numbers (xCoord, yCoord, zCoord) and determine its category (e.g., corner, edge, pit and fissure, etc.), we can use the following steps:

Steps to Derive Axis Numbers and Category from Unique Number:

  1. Convert Unique Number to Indices (i, j, k):

  2. Use integer division and modulo operations to extract i, j, and k from the unique number.

  3. Convert Indices to Axis Numbers (xCoord, yCoord, zCoord):

  4. Subtract 1 from each index to shift the range from (0, 1, 2) to (-1, 0, 1).

  5. Determine Category:

  6. Use the logic for corner, edge, mid, pit and fissure, cervical, proximal, etc., based on the axis numbers.

Code Implementation:

Here’s how you can implement this in JavaScript:

function getAxisNumbersAndCategory(uniqueNumber) {
    // Step 1: Convert unique number to indices (i, j, k)
    let i = Math.floor((uniqueNumber - 1) / 9); // i ranges from 0 to 2
    let j = Math.floor(((uniqueNumber - 1) % 9) / 3); // j ranges from 0 to 2
    let k = (uniqueNumber - 1) % 3; // k ranges from 0 to 2

    // Step 2: Convert indices to axis numbers
    let xCoord = i - 1; // xCoord ranges from -1 to 1
    let yCoord = j - 1; // yCoord ranges from -1 to 1
    let zCoord = k - 1; // zCoord ranges from -1 to 1

    // Step 3: Determine category
    let category = '';
    let nonZeroCount = [xCoord !== 0, yCoord !== 0, zCoord !== 0].filter(Boolean).length;
    if (nonZeroCount === 3) {
        category = 'Corner';
    } else if (nonZeroCount === 2) {
        category = 'Edge';
    } else if (nonZeroCount === 1) {
        category = 'Mid';
    } else {
        category = 'Center';
    }

    // Step 4: Determine area classification
    let area = '';
    if (zCoord === -1) {
        area = 'Cervical';
    } else if (yCoord === 1 || yCoord === -1) {
        area = 'Proximal';
    } else if (xCoord === 1 || xCoord === -1 || zCoord === 1) {
        area = 'Pit and Fissure';
    } else {
        area = 'Smooth Surface';
    }

    return {
**        uniqueNumber**: uniqueNumber,
**        coordinates**: `(${xCoord}, ${yCoord}, ${zCoord})`,
**        category**: category,
**        area**: area
    };
}

// Example usage:
let result = getAxisNumbersAndCategory(16);
console.log(result);

Explanation of the Code:

  1. Step 1: Convert Unique Number to Indices:
  2. i = Math.floor((uniqueNumber - 1) / 9): Determines the x-axis layer.
  3. j = Math.floor(((uniqueNumber - 1) % 9) / 3): Determines the y-axis row within the layer.

  4. k = (uniqueNumber - 1) % 3: Determines the z-axis point within the row.

  5. Step 2: Convert Indices to Axis Numbers:

  6. Subtract 1 from each index to shift the range from (0, 1, 2) to (-1, 0, 1).

  7. Step 3: Determine Category:

  8. Count the number of non-zero coordinates (xCoord, yCoord, zCoord).

  9. Use the count to classify the point as corner, edge, mid, or center.

  10. Step 4: Determine Area Classification:

  11. Use the priority rules (z > y > x) to classify the area as cervical, proximal, pit and fissure, or smooth surface.

Example Output:

For uniqueNumber = 16: 

{
**  uniqueNumber**: 16,
**  coordinates**: "(0, 1, -1)",
**  category**: "Edge",
**  area**: "Proximal"
}

For uniqueNumber = 1: 

{
**  uniqueNumber**: 1,
**  coordinates**: "(-1, -1, -1)",
**  category**: "Corner",
**  area**: "Cervical"
}

For uniqueNumber = 14: 

{
**  uniqueNumber**: 14,
**  coordinates**: "(0, 0, 0)",
**  category**: "Center",
**  area**: "Smooth Surface"
}

Full Mapping Table:

Here’s the full mapping of unique numbers to axis numbers and categories:

Unique Number Coordinates Category Area
1 (-1, -1, -1) Corner Cervical
2 (-1, -1, 0) Edge Proximal
3 (-1, -1, 1) Corner Pit and Fissure
4 (-1, 0, -1) Edge Cervical
5 (-1, 0, 0) Mid Smooth Surface
6 (-1, 0, 1) Edge Pit and Fissure
7 (-1, 1, -1) Corner Cervical
8 (-1, 1, 0) Edge Proximal
9 (-1, 1, 1) Corner Pit and Fissure
10 (0, -1, -1) Edge Cervical
11 (0, -1, 0) Mid Proximal
12 (0, -1, 1) Edge Pit and Fissure
13 (0, 0, -1) Mid Cervical
14 (0, 0, 0) Center Smooth Surface
15 (0, 0, 1) Mid Pit and Fissure
16 (0, 1, -1) Edge Cervical
17 (0, 1, 0) Mid Proximal
18 (0, 1, 1) Edge Pit and Fissure
19 (1, -1, -1) Corner Cervical
20 (1, -1, 0) Edge Proximal
21 (1, -1, 1) Corner Pit and Fissure
22 (1, 0, -1) Edge Cervical
23 (1, 0, 0) Mid Smooth Surface
24 (1, 0, 1) Edge Pit and Fissure
25 (1, 1, -1) Corner Cervical
26 (1, 1, 0) Edge Proximal
27 (1, 1, 1) Corner Pit and Fissure 
pit and fissure = class I

Certainly! Below is the list of unique numbers grouped by their area classifications (e.g., proximal, pit and fissure, cervical, smooth surface) and their corresponding GV Black classes.

Grouped by Area Classification:

1. Pit and Fissure (GV Black Class I):

- Unique Numbers: 3, 6, 9, 12, 15, 18, 21, 24, 27 - Coordinates: - (-1, -1, 1) - (-1, 0, 1) - (-1, 1, 1) - (0, -1, 1) - (0, 0, 1) - (0, 1, 1) - (1, -1, 1) - (1, 0, 1) - (1, 1, 1)

2. Proximal (GV Black Class II):

- Unique Numbers: 2, 5, 8, 11, 14, 17, 20, 23, 26 - Coordinates: - (-1, -1, 0) - (-1, 0, 0) - (-1, 1, 0) - (0, -1, 0) - (0, 0, 0) - (0, 1, 0) - (1, -1, 0) - (1, 0, 0) - (1, 1, 0)

3. Cervical (GV Black Class V):

- Unique Numbers: 1, 4, 7, 10, 13, 16, 19, 22, 25 - Coordinates: - (-1, -1, -1) - (-1, 0, -1) - (-1, 1, -1) - (0, -1, -1) - (0, 0, -1) - (0, 1, -1) - (1, -1, -1) - (1, 0, -1) - (1, 1, -1)

4. Smooth Surface (GV Black Class II):

- Unique Numbers: 5, 14, 23 - Coordinates: - (-1, 0, 0) - (0, 0, 0) - (1, 0, 0)

Summary Table:

Area Classification GV Black Class Unique Numbers
Pit and Fissure Class I 3, 6, 9, 12, 15, 18, 21, 24, 27
Proximal Class II 2, 5, 8, 11, 14, 17, 20, 23, 26
Cervical Class V 1, 4, 7, 10, 13, 16, 19, 22, 25
Smooth Surface Class II 5, 14, 23

Notes:

  1. Pit and Fissure:
  2. These are points where z = 1 or x = ±1.

  3. They are classified as Class I because they involve pits and fissures.

  4. Proximal:

  5. These are points where y = ±1 and z = 0.

  6. They are classified as Class II because they involve proximal surfaces.

  7. Cervical:

  8. These are points where z = -1.

  9. They are classified as Class V because they involve the cervical third of the tooth.

  10. Smooth Surface:

  11. These are points where x = 0, y = 0, and z = 0.
  12. They are classified as Class II because they involve smooth surfaces (assumed to be proximal).

Let me know if you need further clarification or adjustments! 😊

To determine if unique numbers 4 and 5 are adjacent, we need to:

  1. Convert the unique numbers to their coordinates.
  2. Check if the coordinates differ by exactly 1 in one axis (x, y, or z).

Step-by-Step Explanation:

1. Convert Unique Numbers to Coordinates:

** - The formula to convert a unique number to coordinates is**: 

let i = Math.floor((uniqueNumber - 1) / 9); // i ranges from 0 to 2
let j = Math.floor(((uniqueNumber - 1) % 9) / 3); // j ranges from 0 to 2
let k = (uniqueNumber - 1) % 3; // k ranges from 0 to 2
let xCoord = i - 1; // xCoord ranges from -1 to 1
let yCoord = j - 1; // yCoord ranges from -1 to 1
let zCoord = k - 1; // zCoord ranges from -1 to 1

  • For unique number 4: 

    let i = Math.floor((4 - 1) / 9); // i = 0
let j = Math.floor(((4 - 1) % 9) / 3); // j = 1
let k = (4 - 1) % 3; // k = 0
let xCoord = 0 - 1; // xCoord = -1
let yCoord = 1 - 1; // yCoord = 0
let zCoord = 0 - 1; // zCoord = -1
    ** Coordinates**: (-1, 0, -1)

  • For unique number 5: 

    let i = Math.floor((5 - 1) / 9); // i = 0
let j = Math.floor(((5 - 1) % 9) / 3); // j = 1
let k = (5 - 1) % 3; // k = 1
let xCoord = 0 - 1; // xCoord = -1
let yCoord = 1 - 1; // yCoord = 0
let zCoord = 1 - 1; // zCoord = 0
    ** Coordinates**: (-1, 0, 0)

2. Check if Coordinates Are Adjacent:

  • Two points are adjacent if their coordinates differ by exactly 1 in one axis (x, y, or z) and are the same in the other two axes.

  • Compare the coordinates of unique numbers 4 and 5:

    • xCoord: -1 (for both) → same.
    • yCoord: 0 (for both) → same.
    • zCoord: -1 (for 4) and 0 (for 5) → differ by 1.

  • Since the zCoord differs by exactly 1, the points are adjacent.

Code Implementation:

Here’s the JavaScript code to check if two unique numbers are adjacent:

// Function to get coordinates from unique number
function getCoordinates(uniqueNumber) {
    let i = Math.floor((uniqueNumber - 1) / 9); // i ranges from 0 to 2
    let j = Math.floor(((uniqueNumber - 1) % 9) / 3); // j ranges from 0 to 2
    let k = (uniqueNumber - 1) % 3; // k ranges from 0 to 2
    return [i - 1, j - 1, k - 1]; // Convert to (-1, 0, 1) range
}

// Function to check if two points are adjacent
function areAdjacent(uniqueNumber1, uniqueNumber2) {
    let coord1 = getCoordinates(uniqueNumber1);
    let coord2 = getCoordinates(uniqueNumber2);

    // Calculate the difference in coordinates
    let dx = Math.abs(coord1[0] - coord2[0]);
    let dy = Math.abs(coord1[1] - coord2[1]);
    let dz = Math.abs(coord1[2] - coord2[2]);

    // Check if the points differ by exactly 1 in one axis
    return (dx + dy + dz) === 1;
}

// Check if unique numbers 4 and 5 are adjacent
let isAdjacent = areAdjacent(4, 5);
console.log('Are 4 and 5 adjacent?', isAdjacent); // Output: true

Explanation of the Code:

  1. getCoordinates Function:

  2. Converts a unique number to its corresponding coordinates (xCoord, yCoord, zCoord).

  3. areAdjacent Function:

  4. Compares the coordinates of two unique numbers.

  5. Checks if the coordinates differ by exactly 1 in one axis (x, y, or z).

  6. Output:

  7. For unique numbers 4 and 5, the function returns true because they are adjacent.

Example Output:

Input:

let isAdjacent = areAdjacent(4, 5);

Output:

Are 4 and 5 adjacent? true

Adjacency Rules:

Two points are adjacent if: - Their xCoord differs by 1, and yCoord and zCoord are the same. - Their yCoord differs by 1, and xCoord and zCoord are the same. - Their zCoord differs by 1, and xCoord and yCoord are the same.

Full Adjacency List for Unique Number 4:

Here are all the unique numbers adjacent to unique number 4:

Unique Number Coordinates Adjacent Unique Numbers
4 (-1, 0, -1) 1, 5, 7, 13
  • 1: (-1, -1, -1) → Adjacent in yCoord.
  • 5: (-1, 0, 0) → Adjacent in zCoord.
  • 7: (-1, 1, -1) → Adjacent in yCoord.
  • 13: (0, 0, -1) → Adjacent in xCoord.

Full Adjacency List for Unique Number 5:

Here are all the unique numbers adjacent to unique number 5:

Unique Number Coordinates Adjacent Unique Numbers
5 (-1, 0, 0) 2, 4, 6, 8, 14
  • 2: (-1, -1, 0) → Adjacent in yCoord.
  • 4: (-1, 0, -1) → Adjacent in zCoord.
  • 6: (-1, 0, 1) → Adjacent in zCoord.
  • 8: (-1, 1, 0) → Adjacent in yCoord.
  • 14: (0, 0, 0) → Adjacent in xCoord.

Conclusion:

  • Unique numbers 4 and 5 are adjacent because their zCoord differs by exactly 1.
  • You can use the areAdjacent function to check adjacency for any pair of unique numbers.

Let me know if you need further clarification! 😊

To classify a cavity into the appropriate GV Black class, we need to analyze the location and extent of the caries (decay) based on the unique numbers and their coordinates. Here's how we can do it:

GV Black's Classification:

  1. Class I: Cavities in pits and fissures.
  2. Class II: Cavities on the proximal surfaces of premolars and molars.
  3. Class III: Cavities on the proximal surfaces of incisors and canines that do not involve the incisal angle.
  4. Class IV: Cavities on the proximal surfaces of incisors and canines that involve the incisal angle.
  5. Class V: Cavities in the cervical third of the facial or lingual surfaces.
  6. Class VI: Cavities on the incisal edges of anterior teeth or the cusp tips of posterior teeth.

Steps to Classify Cavities:

  1. Identify the Area:

  2. Use the coordinates of the unique numbers to determine the area (e.g., pit and fissure, proximal, cervical, smooth surface).

  3. Check Adjacent Caries:

  4. If caries are found in adjacent areas, they may form a larger cavity.

  5. Classify the Cavity:

  6. Use the area classification and adjacent findings to determine the appropriate GV Black class.

Code Implementation:

Here’s the JavaScript code to classify cavities based on the unique numbers and their coordinates:

// Function to get coordinates from unique number
function getCoordinates(uniqueNumber) {
    let i = Math.floor((uniqueNumber - 1) / 9); // i ranges from 0 to 2
    let j = Math.floor(((uniqueNumber - 1) % 9) / 3); // j ranges from 0 to 2
    let k = (uniqueNumber - 1) % 3; // k ranges from 0 to 2
    return [i - 1, j - 1, k - 1]; // Convert to (-1, 0, 1) range
}

// Function to check if two points are adjacent
function areAdjacent(uniqueNumber1, uniqueNumber2) {
    let coord1 = getCoordinates(uniqueNumber1);
    let coord2 = getCoordinates(uniqueNumber2);

    // Calculate the difference in coordinates
    let dx = Math.abs(coord1[0] - coord2[0]);
    let dy = Math.abs(coord1[1] - coord2[1]);
    let dz = Math.abs(coord1[2] - coord2[2]);

    // Check if the points differ by exactly 1 in one axis
    return (dx + dy + dz) === 1;
}

// Function to classify cavity based on unique numbers
function classifyCavity(cariesFound) {
    let areaClassification = [];
    let adjacentPairs = [];

    // Step 1: Classify each caries based on its coordinates
    for (let uniqueNumber of cariesFound) {
        let [xCoord, yCoord, zCoord] = getCoordinates(uniqueNumber);

        if (zCoord === -1) {
            areaClassification.push({ uniqueNumber, area: 'Cervical', gvBlackClass: 'Class V' });
        } else if (yCoord === 1 || yCoord === -1) {
            areaClassification.push({ uniqueNumber, area: 'Proximal', gvBlackClass: 'Class II' });
        } else if (xCoord === 1 || xCoord === -1 || zCoord === 1) {
            areaClassification.push({ uniqueNumber, area: 'Pit and Fissure', gvBlackClass: 'Class I' });
        } else {
            areaClassification.push({ uniqueNumber, area: 'Smooth Surface', gvBlackClass: 'Class II' });
        }
    }

    // Step 2: Check for adjacent caries
    for (let i = 0; i < cariesFound.length; i++) {
        for (let j = i + 1; j < cariesFound.length; j++) {
            if (areAdjacent(cariesFound[i], cariesFound[j])) {
                adjacentPairs.push([cariesFound[i], cariesFound[j]]);
            }
        }
    }

    // Step 3: Determine the final cavity class
    let cavityClass = 'Unknown';
    if (adjacentPairs.length > 0) {
        // If adjacent caries are found, classify as Class II (proximal surfaces)
        cavityClass = 'Class II';
    } else {
        // If no adjacent caries, use the area classification of the first caries
        cavityClass = areaClassification[0].gvBlackClass;
    }

    return {
        areaClassification,
        adjacentPairs,
        cavityClass
    };
}

// Example usage:
let cariesFound = [4, 5]; // Caries found at unique numbers 4 and 5
let result = classifyCavity(cariesFound);
console.log(result);

Example Output:

Input:

let cariesFound = [4, 5];

Output:

{
**  areaClassification**: [
    { uniqueNumber: 4, area: 'Cervical', gvBlackClass: 'Class V' },
    { uniqueNumber: 5, area: 'Smooth Surface', gvBlackClass: 'Class II' }
  ],
**  adjacentPairs**: [[4, 5]],
**  cavityClass**: 'Class II'
}

Explanation of the Output:

  1. Area Classification:
  2. Unique number 4: Located at (-1, 0, -1) → Cervical → Class V.

  3. Unique number 5: Located at (-1, 0, 0) → Smooth Surface → Class II.

  4. Adjacent Pairs:

  5. Unique numbers 4 and 5 are adjacent because their zCoord differs by exactly 1.

  6. Cavity Class:

  7. Since caries are found in adjacent areas, the cavity is classified as Class II.

Rules for Classification:

  1. Class I:

  2. Caries in pit and fissure areas (xCoord = ±1 or zCoord = 1).

  3. Class II:

  4. Caries on proximal surfaces (yCoord = ±1).

  5. If caries are found in adjacent areas, they form a Class II cavity.

  6. Class V:

  7. Caries in the cervical third (zCoord = -1).

  8. Class VI:

  9. Caries on the incisal edges or cusp tips (not explicitly covered in this example).

Full Classification Table:

Here’s the full mapping of unique numbers to their area classification and GV Black class:

Unique Number Coordinates Area GV Black Class
1 (-1, -1, -1) Cervical Class V
2 (-1, -1, 0) Proximal Class II
3 (-1, -1, 1) Pit and Fissure Class I
4 (-1, 0, -1) Cervical Class V
5 (-1, 0, 0) Smooth Surface Class II
6 (-1, 0, 1) Pit and Fissure Class I
7 (-1, 1, -1) Cervical Class V
8 (-1, 1, 0) Proximal Class II
9 (-1, 1, 1) Pit and Fissure Class I
10 (0, -1, -1) Cervical Class V
11 (0, -1, 0) Proximal Class II
12 (0, -1, 1) Pit and Fissure Class I
13 (0, 0, -1) Cervical Class V
14 (0, 0, 0) Smooth Surface Class II
15 (0, 0, 1) Pit and Fissure Class I
16 (0, 1, -1) Cervical Class V
17 (0, 1, 0) Proximal Class II
18 (0, 1, 1) Pit and Fissure Class I
19 (1, -1, -1) Cervical Class V
20 (1, -1, 0) Proximal Class II
21 (1, -1, 1) Pit and Fissure Class I
22 (1, 0, -1) Cervical Class V
23 (1, 0, 0) Smooth Surface Class II
24 (1, 0, 1) Pit and Fissure Class I
25 (1, 1, -1) Cervical Class V
26 (1, 1, 0) Proximal Class II
27 (1, 1, 1) Pit and Fissure Class I

Conclusion:

  • Use the coordinates of the unique numbers to determine the area classification.
  • Check for adjacent caries to determine if they form a larger cavity.
  • Classify the cavity based on the area and adjacent findings.

Let me know if you need further clarification or enhancements! 😊

Tooth Classifier

Tooth Information Finder

Result: