@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/esm/src/analysis/analysis.js

@@ -1 +1,536 @@
-import{createClass as e,classCallCheck as t}from"../../_virtual/_rollupPluginBabelHelpers.js";import*as n from"three";import{logger as i}from"../core/debugLogger.js";var a=function(){return e(function e(){t(this,e),this.analysisHistory=[],this.validationRules=new Map,this.adjustmentStrategies=new Map,this.initializeDefaultRules()},[{key:"initializeDefaultRules",value:function(){this.addValidationRule("component_bounds",{check:function(e){var t=(new n.Box3).setFromObject(e);return!t.isEmpty()&&t.getSize(new n.Vector3).length()>0},message:"Component has invalid bounding box"}),this.addValidationRule("component_position",{check:function(e){var t=e.position;return!isNaN(t.x)&&!isNaN(t.y)&&!isNaN(t.z)&&isFinite(t.x)&&isFinite(t.y)&&isFinite(t.z)},message:"Component has invalid position values"}),this.addValidationRule("component_scale",{check:function(e){var t=e.scale;return t.x>0&&t.y>0&&t.z>0&&t.x<1e3&&t.y<1e3&&t.z<1e3},message:"Component has invalid scale values"}),this.addValidationRule("scene_complexity",{check:function(e){var t=0;return e.traverse(function(e){e.isMesh&&t++}),t<1e4},message:"Scene complexity too high (too many meshes)"})}},{key:"addValidationRule",value:function(e,t){this.validationRules.set(e,t)}},{key:"addAdjustmentStrategy",value:function(e,t){this.adjustmentStrategies.set(e,t)}},{key:"analyzeScene",value:function(e){var t=performance.now();i.info("🔍 Starting scene analysis...");var n={timestamp:(new Date).toISOString(),performance:{},structure:{},quality:{},recommendations:[]},a=0,r=0,s=0,o=0,u=new Set,c=new Set;e.traverse(function(e){if(e.isMesh){if(a++,e.geometry){r++;var t=e.geometry.getAttribute("position");t&&(s+=t.count,e.geometry.index?o+=e.geometry.index.count/3:o+=t.count/3)}if(e.material)if(Array.isArray(e.material))e.material.forEach(function(e){return u.add(e.uuid)});else{u.add(e.material.uuid);var n=e.material;Object.keys(n).forEach(function(e){n[e]&&n[e].isTexture&&c.add(n[e].uuid)})}}}),n.performance={meshCount:a,geometryCount:r,materialCount:u.size,textureCount:c.size,vertexCount:s,triangleCount:o,memoryEstimate:this.estimateMemoryUsage(s,u.size,c.size)},n.structure=this.analyzeSceneStructure(e),n.quality=this.analyzeQuality(e),n.recommendations=this.generateRecommendations(n);var l=performance.now();return n.performance.analysisTime=l-t,i.info("✅ Scene analysis complete in ".concat(n.performance.analysisTime.toFixed(2),"ms")),this.analysisHistory.push(n),n}},{key:"analyzeSceneStructure",value:function(e){var t={depth:0,branches:0,emptyNodes:0,namedObjects:0,groups:0},n=function(e){var i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;t.depth=Math.max(t.depth,i),e.children.length>0&&t.branches++,0!==e.children.length||e.isMesh||e.isLight||e.isCamera||t.emptyNodes++,e.name&&""!==e.name.trim()&&t.namedObjects++,e.isGroup&&t.groups++,e.children.forEach(function(e){return n(e,i+1)})};return n(e),t}},{key:"analyzeQuality",value:function(e){var t=this,n={duplicateMaterials:0,unusedMaterials:0,missingTextures:0,invalidTransforms:0,memoryLeaks:[],optimization:{mergeable:[],instancingCandidates:[]}},i=new Map,a=new Map;return e.traverse(function(e){if(e.material){var r=t.getMaterialSignature(e.material);i.has(r)?n.duplicateMaterials++:i.set(r,e.material)}if(e.geometry){var s=t.getGeometrySignature(e.geometry);a.has(s)||a.set(s,[]),a.get(s).push(e)}!e.position||isFinite(e.position.x)&&isFinite(e.position.y)&&isFinite(e.position.z)||n.invalidTransforms++}),a.forEach(function(e,t){e.length>1&&n.optimization.instancingCandidates.push({geometry:t,count:e.length,objects:e.map(function(e){return e.uuid})})}),n}},{key:"generateRecommendations",value:function(e){var t=[];return e.performance.triangleCount>5e5&&t.push({type:"performance",priority:"high",message:"Consider using Level of Detail (LOD) for high polygon models",action:"implement_lod"}),e.performance.materialCount>50&&t.push({type:"performance",priority:"medium",message:"High material count detected. Consider material atlasing",action:"optimize_materials"}),e.quality.duplicateMaterials>10&&t.push({type:"optimization",priority:"medium",message:"Duplicate materials found. Consider material sharing",action:"merge_materials"}),e.quality.optimization.instancingCandidates.length>0&&t.push({type:"optimization",priority:"high",message:"Instancing opportunities detected for repeated geometries",action:"implement_instancing"}),t}},{key:"validateScene",value:function(e){var t=this;i.info("🔍 Validating scene components...");var n={passed:[],failed:[],warnings:[]};return this.validationRules.forEach(function(t,i){try{t.check(e)?n.passed.push({rule:i,target:"scene"}):n.failed.push({rule:i,target:"scene",message:t.message})}catch(e){n.warnings.push({rule:i,target:"scene",message:"Validation error: ".concat(e.message)})}}),e.traverse(function(e){e.isMesh&&t.validationRules.forEach(function(t,i){try{t.check(e)?n.passed.push({rule:i,target:e.uuid}):n.failed.push({rule:i,target:e.uuid,message:t.message,objectName:e.name||"Unnamed Object"})}catch(t){n.warnings.push({rule:i,target:e.uuid,message:"Validation error: ".concat(t.message),objectName:e.name||"Unnamed Object"})}})}),i.info("✅ Validation complete: ".concat(n.passed.length," passed, ").concat(n.failed.length," failed, ").concat(n.warnings.length," warnings")),n}},{key:"applyAdjustments",value:function(e){var t=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:[];i.info("🔧 Applying scene adjustments...");var a={applied:[],failed:[],skipped:[]};return n.forEach(function(n){var i=t.adjustmentStrategies.get(n.type);if(i)try{var r=i(e,n.options||{});a.applied.push({adjustment:n.type,result:r})}catch(e){a.failed.push({adjustment:n.type,error:e.message})}else a.skipped.push({adjustment:n.type,reason:"No strategy found"})}),i.info("✅ Adjustments complete: ".concat(a.applied.length," applied, ").concat(a.failed.length," failed, ").concat(a.skipped.length," skipped")),a}},{key:"getMaterialSignature",value:function(e){var t={type:e.type,color:e.color?e.color.getHex():null,metalness:e.metalness,roughness:e.roughness,transparent:e.transparent,opacity:e.opacity};return JSON.stringify(t)}},{key:"getGeometrySignature",value:function(e){var t,n=Object.keys(e.attributes),i=(null===(t=e.getAttribute("position"))||void 0===t?void 0:t.count)||0,a=!!e.index;return"".concat(e.type,"_").concat(i,"_").concat(a,"_").concat(n.join(","))}},{key:"estimateMemoryUsage",value:function(e,t,n){var i=32*e,a=1024*t,r=1048576*n,s=i+a+r;return{geometry:this.formatBytes(i),materials:this.formatBytes(a),textures:this.formatBytes(r),total:this.formatBytes(s),totalBytes:s}}},{key:"formatBytes",value:function(e){if(0===e)return"0 Bytes";var t=Math.floor(Math.log(e)/Math.log(1024));return parseFloat((e/Math.pow(1024,t)).toFixed(2))+" "+["Bytes","KB","MB","GB"][t]}},{key:"getAnalysisHistory",value:function(){return this.analysisHistory}},{key:"clearHistory",value:function(){this.analysisHistory=[]}},{key:"dispose",value:function(){this.clearHistory(),this.validationRules.clear(),this.adjustmentStrategies.clear(),i.info("Analysis disposed")}}])}();export{a as Analysis};
+import { createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { logger } from '../core/debugLogger.js';
+
+var Analysis = /*#__PURE__*/function () {
+  function Analysis() {
+    _classCallCheck(this, Analysis);
+    this.analysisHistory = [];
+    this.validationRules = new Map();
+    this.adjustmentStrategies = new Map();
+    this.initializeDefaultRules();
+  }
+
+  /**
+   * Initialize default validation rules
+   */
+  return _createClass(Analysis, [{
+    key: "initializeDefaultRules",
+    value: function initializeDefaultRules() {
+      // Component validation rules
+      this.addValidationRule('component_bounds', {
+        check: function check(component) {
+          var bbox = new THREE.Box3().setFromObject(component);
+          return !bbox.isEmpty() && bbox.getSize(new THREE.Vector3()).length() > 0;
+        },
+        message: 'Component has invalid bounding box'
+      });
+      this.addValidationRule('component_position', {
+        check: function check(component) {
+          var pos = component.position;
+          return !isNaN(pos.x) && !isNaN(pos.y) && !isNaN(pos.z) && isFinite(pos.x) && isFinite(pos.y) && isFinite(pos.z);
+        },
+        message: 'Component has invalid position values'
+      });
+      this.addValidationRule('component_scale', {
+        check: function check(component) {
+          var scale = component.scale;
+          return scale.x > 0 && scale.y > 0 && scale.z > 0 && scale.x < 1000 && scale.y < 1000 && scale.z < 1000;
+        },
+        message: 'Component has invalid scale values'
+      });
+
+      // Scene validation rules
+      this.addValidationRule('scene_complexity', {
+        check: function check(scene) {
+          var meshCount = 0;
+          scene.traverse(function (obj) {
+            if (obj.isMesh) meshCount++;
+          });
+          return meshCount < 10000; // Arbitrary limit
+        },
+        message: 'Scene complexity too high (too many meshes)'
+      });
+    }
+
+    /**
+     * Add a validation rule
+     * @param {string} name - Rule name
+     * @param {Object} rule - Rule object with check function and message
+     */
+  }, {
+    key: "addValidationRule",
+    value: function addValidationRule(name, rule) {
+      this.validationRules.set(name, rule);
+    }
+
+    /**
+     * Add an adjustment strategy
+     * @param {string} name - Strategy name
+     * @param {Function} strategy - Adjustment function
+     */
+  }, {
+    key: "addAdjustmentStrategy",
+    value: function addAdjustmentStrategy(name, strategy) {
+      this.adjustmentStrategies.set(name, strategy);
+    }
+
+    /**
+     * Analyze scene composition and structure
+     * @param {THREE.Scene} scene - Scene to analyze
+     * @returns {Object} Analysis results
+     */
+  }, {
+    key: "analyzeScene",
+    value: function analyzeScene(scene) {
+      var startTime = performance.now();
+      logger.info('🔍 Starting scene analysis...');
+      var analysis = {
+        timestamp: new Date().toISOString(),
+        performance: {},
+        structure: {},
+        quality: {},
+        recommendations: []
+      };
+
+      // Performance analysis
+      var meshCount = 0;
+      var geometryCount = 0;
+      var vertexCount = 0;
+      var triangleCount = 0;
+      var materials = new Set();
+      var textures = new Set();
+      scene.traverse(function (object) {
+        if (object.isMesh) {
+          meshCount++;
+          if (object.geometry) {
+            geometryCount++;
+
+            // Count vertices and triangles
+            var positionAttribute = object.geometry.getAttribute('position');
+            if (positionAttribute) {
+              vertexCount += positionAttribute.count;
+              if (object.geometry.index) {
+                triangleCount += object.geometry.index.count / 3;
+              } else {
+                triangleCount += positionAttribute.count / 3;
+              }
+            }
+          }
+          if (object.material) {
+            if (Array.isArray(object.material)) {
+              object.material.forEach(function (mat) {
+                return materials.add(mat.uuid);
+              });
+            } else {
+              materials.add(object.material.uuid);
+
+              // Count textures
+              var material = object.material;
+              Object.keys(material).forEach(function (key) {
+                if (material[key] && material[key].isTexture) {
+                  textures.add(material[key].uuid);
+                }
+              });
+            }
+          }
+        }
+      });
+      analysis.performance = {
+        meshCount: meshCount,
+        geometryCount: geometryCount,
+        materialCount: materials.size,
+        textureCount: textures.size,
+        vertexCount: vertexCount,
+        triangleCount: triangleCount,
+        memoryEstimate: this.estimateMemoryUsage(vertexCount, materials.size, textures.size)
+      };
+
+      // Structure analysis
+      analysis.structure = this.analyzeSceneStructure(scene);
+
+      // Quality analysis
+      analysis.quality = this.analyzeQuality(scene);
+
+      // Generate recommendations
+      analysis.recommendations = this.generateRecommendations(analysis);
+      var endTime = performance.now();
+      analysis.performance.analysisTime = endTime - startTime;
+      logger.info("\u2705 Scene analysis complete in ".concat(analysis.performance.analysisTime.toFixed(2), "ms"));
+      this.analysisHistory.push(analysis);
+      return analysis;
+    }
+
+    /**
+     * Analyze scene structure and hierarchy
+     * @param {THREE.Scene} scene - Scene to analyze
+     * @returns {Object} Structure analysis
+     */
+  }, {
+    key: "analyzeSceneStructure",
+    value: function analyzeSceneStructure(scene) {
+      var structure = {
+        depth: 0,
+        branches: 0,
+        emptyNodes: 0,
+        namedObjects: 0,
+        groups: 0
+      };
+      var _analyzeNode = function analyzeNode(node) {
+        var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+        structure.depth = Math.max(structure.depth, depth);
+        if (node.children.length > 0) {
+          structure.branches++;
+        }
+        if (node.children.length === 0 && !node.isMesh && !node.isLight && !node.isCamera) {
+          structure.emptyNodes++;
+        }
+        if (node.name && node.name.trim() !== '') {
+          structure.namedObjects++;
+        }
+        if (node.isGroup) {
+          structure.groups++;
+        }
+        node.children.forEach(function (child) {
+          return _analyzeNode(child, depth + 1);
+        });
+      };
+      _analyzeNode(scene);
+      return structure;
+    }
+
+    /**
+     * Analyze scene quality metrics
+     * @param {THREE.Scene} scene - Scene to analyze
+     * @returns {Object} Quality analysis
+     */
+  }, {
+    key: "analyzeQuality",
+    value: function analyzeQuality(scene) {
+      var _this = this;
+      var quality = {
+        duplicateMaterials: 0,
+        unusedMaterials: 0,
+        missingTextures: 0,
+        invalidTransforms: 0,
+        memoryLeaks: [],
+        optimization: {
+          mergeable: [],
+          instancingCandidates: []
+        }
+      };
+      var materials = new Map();
+      var geometries = new Map();
+      scene.traverse(function (object) {
+        // Check for duplicate materials
+        if (object.material) {
+          var matKey = _this.getMaterialSignature(object.material);
+          if (materials.has(matKey)) {
+            quality.duplicateMaterials++;
+          } else {
+            materials.set(matKey, object.material);
+          }
+        }
+
+        // Check for duplicate geometries (instancing candidates)
+        if (object.geometry) {
+          var geoKey = _this.getGeometrySignature(object.geometry);
+          if (!geometries.has(geoKey)) {
+            geometries.set(geoKey, []);
+          }
+          geometries.get(geoKey).push(object);
+        }
+
+        // Check for invalid transforms
+        if (object.position && (!isFinite(object.position.x) || !isFinite(object.position.y) || !isFinite(object.position.z))) {
+          quality.invalidTransforms++;
+        }
+      });
+
+      // Find instancing candidates
+      geometries.forEach(function (objects, geoKey) {
+        if (objects.length > 1) {
+          quality.optimization.instancingCandidates.push({
+            geometry: geoKey,
+            count: objects.length,
+            objects: objects.map(function (obj) {
+              return obj.uuid;
+            })
+          });
+        }
+      });
+      return quality;
+    }
+
+    /**
+     * Generate optimization recommendations
+     * @param {Object} analysis - Analysis results
+     * @returns {Array} Recommendations
+     */
+  }, {
+    key: "generateRecommendations",
+    value: function generateRecommendations(analysis) {
+      var recommendations = [];
+
+      // Performance recommendations
+      if (analysis.performance.triangleCount > 500000) {
+        recommendations.push({
+          type: 'performance',
+          priority: 'high',
+          message: 'Consider using Level of Detail (LOD) for high polygon models',
+          action: 'implement_lod'
+        });
+      }
+      if (analysis.performance.materialCount > 50) {
+        recommendations.push({
+          type: 'performance',
+          priority: 'medium',
+          message: 'High material count detected. Consider material atlasing',
+          action: 'optimize_materials'
+        });
+      }
+      if (analysis.quality.duplicateMaterials > 10) {
+        recommendations.push({
+          type: 'optimization',
+          priority: 'medium',
+          message: 'Duplicate materials found. Consider material sharing',
+          action: 'merge_materials'
+        });
+      }
+      if (analysis.quality.optimization.instancingCandidates.length > 0) {
+        recommendations.push({
+          type: 'optimization',
+          priority: 'high',
+          message: 'Instancing opportunities detected for repeated geometries',
+          action: 'implement_instancing'
+        });
+      }
+      return recommendations;
+    }
+
+    /**
+     * Validate scene components
+     * @param {THREE.Scene} scene - Scene to validate
+     * @returns {Object} Validation results
+     */
+  }, {
+    key: "validateScene",
+    value: function validateScene(scene) {
+      var _this2 = this;
+      logger.info('🔍 Validating scene components...');
+      var validation = {
+        passed: [],
+        failed: [],
+        warnings: []
+      };
+
+      // Validate scene itself
+      this.validationRules.forEach(function (rule, name) {
+        try {
+          if (rule.check(scene)) {
+            validation.passed.push({
+              rule: name,
+              target: 'scene'
+            });
+          } else {
+            validation.failed.push({
+              rule: name,
+              target: 'scene',
+              message: rule.message
+            });
+          }
+        } catch (error) {
+          validation.warnings.push({
+            rule: name,
+            target: 'scene',
+            message: "Validation error: ".concat(error.message)
+          });
+        }
+      });
+
+      // Validate individual components
+      scene.traverse(function (object) {
+        if (object.isMesh) {
+          _this2.validationRules.forEach(function (rule, name) {
+            try {
+              if (rule.check(object)) {
+                validation.passed.push({
+                  rule: name,
+                  target: object.uuid
+                });
+              } else {
+                validation.failed.push({
+                  rule: name,
+                  target: object.uuid,
+                  message: rule.message,
+                  objectName: object.name || 'Unnamed Object'
+                });
+              }
+            } catch (error) {
+              validation.warnings.push({
+                rule: name,
+                target: object.uuid,
+                message: "Validation error: ".concat(error.message),
+                objectName: object.name || 'Unnamed Object'
+              });
+            }
+          });
+        }
+      });
+      logger.info("\u2705 Validation complete: ".concat(validation.passed.length, " passed, ").concat(validation.failed.length, " failed, ").concat(validation.warnings.length, " warnings"));
+      return validation;
+    }
+
+    /**
+     * Apply automatic adjustments to scene
+     * @param {THREE.Scene} scene - Scene to adjust
+     * @param {Array} adjustments - List of adjustments to apply
+     * @returns {Object} Adjustment results
+     */
+  }, {
+    key: "applyAdjustments",
+    value: function applyAdjustments(scene) {
+      var _this3 = this;
+      var adjustments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      logger.info('🔧 Applying scene adjustments...');
+      var results = {
+        applied: [],
+        failed: [],
+        skipped: []
+      };
+      adjustments.forEach(function (adjustment) {
+        var strategy = _this3.adjustmentStrategies.get(adjustment.type);
+        if (!strategy) {
+          results.skipped.push({
+            adjustment: adjustment.type,
+            reason: 'No strategy found'
+          });
+          return;
+        }
+        try {
+          var result = strategy(scene, adjustment.options || {});
+          results.applied.push({
+            adjustment: adjustment.type,
+            result: result
+          });
+        } catch (error) {
+          results.failed.push({
+            adjustment: adjustment.type,
+            error: error.message
+          });
+        }
+      });
+      logger.info("\u2705 Adjustments complete: ".concat(results.applied.length, " applied, ").concat(results.failed.length, " failed, ").concat(results.skipped.length, " skipped"));
+      return results;
+    }
+
+    /**
+     * Get material signature for comparison
+     * @param {THREE.Material} material - Material to analyze
+     * @returns {string} Material signature
+     */
+  }, {
+    key: "getMaterialSignature",
+    value: function getMaterialSignature(material) {
+      var props = {
+        type: material.type,
+        color: material.color ? material.color.getHex() : null,
+        metalness: material.metalness,
+        roughness: material.roughness,
+        transparent: material.transparent,
+        opacity: material.opacity
+      };
+      return JSON.stringify(props);
+    }
+
+    /**
+     * Get geometry signature for comparison
+     * @param {THREE.BufferGeometry} geometry - Geometry to analyze
+     * @returns {string} Geometry signature
+     */
+  }, {
+    key: "getGeometrySignature",
+    value: function getGeometrySignature(geometry) {
+      var _geometry$getAttribut;
+      var attributes = Object.keys(geometry.attributes);
+      var vertexCount = ((_geometry$getAttribut = geometry.getAttribute('position')) === null || _geometry$getAttribut === void 0 ? void 0 : _geometry$getAttribut.count) || 0;
+      var hasIndex = !!geometry.index;
+      return "".concat(geometry.type, "_").concat(vertexCount, "_").concat(hasIndex, "_").concat(attributes.join(','));
+    }
+
+    /**
+     * Estimate memory usage
+     * @param {number} vertices - Vertex count
+     * @param {number} materials - Material count
+     * @param {number} textures - Texture count
+     * @returns {Object} Memory estimates
+     */
+  }, {
+    key: "estimateMemoryUsage",
+    value: function estimateMemoryUsage(vertices, materials, textures) {
+      var bytesPerVertex = 32; // Rough estimate for position + normal + uv
+      var bytesPerMaterial = 1024; // Rough estimate
+      var bytesPerTexture = 1024 * 1024; // Assume 1MB average per texture
+
+      var geometryMemory = vertices * bytesPerVertex;
+      var materialMemory = materials * bytesPerMaterial;
+      var textureMemory = textures * bytesPerTexture;
+      var total = geometryMemory + materialMemory + textureMemory;
+      return {
+        geometry: this.formatBytes(geometryMemory),
+        materials: this.formatBytes(materialMemory),
+        textures: this.formatBytes(textureMemory),
+        total: this.formatBytes(total),
+        totalBytes: total
+      };
+    }
+
+    /**
+     * Format bytes to human readable format
+     * @param {number} bytes - Bytes to format
+     * @returns {string} Formatted string
+     */
+  }, {
+    key: "formatBytes",
+    value: function formatBytes(bytes) {
+      if (bytes === 0) return '0 Bytes';
+      var k = 1024;
+      var sizes = ['Bytes', 'KB', 'MB', 'GB'];
+      var i = Math.floor(Math.log(bytes) / Math.log(k));
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+
+    /**
+     * Get analysis history
+     * @returns {Array} Analysis history
+     */
+  }, {
+    key: "getAnalysisHistory",
+    value: function getAnalysisHistory() {
+      return this.analysisHistory;
+    }
+
+    /**
+     * Clear analysis history
+     */
+  }, {
+    key: "clearHistory",
+    value: function clearHistory() {
+      this.analysisHistory = [];
+    }
+
+    /**
+     * Dispose of analysis manager
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.clearHistory();
+      this.validationRules.clear();
+      this.adjustmentStrategies.clear();
+      logger.info('Analysis disposed');
+    }
+  }]);
+}();
+
+export { Analysis };