[1515390048]

如图，在Ai中怎样把虚线快速剪成一小段的。(目的是导出CAD后，齿刀变成一条线了)

[sxan8249]

将文件导出格式为window元件，然后再打开就是齿刀了

[tanshiyu]

用这个脚本，用这个脚本，用这个脚本，用这个脚本，用这个脚本。

// breakDashes.jsx
// adobe Illustrator CSx script
// breaks each dashed path into a series of lines
//
// USAGE:
// Select paths and run this script.
//
// NOTE1: Illustrator's native dashes adjustment
// feature is ignored because it is totally
// out of control from JavaScript.
//
// 2018.07.20, modified to ignore locked/hidden objects in a selected group

// Copyright(c) 2014 Hiroyuki Sato
// https://github.com/shspage
// This script is distributed under the MIT License.
// See the LICENSE file for details.

function main(){

// use_group: set true to gather broken paths into a group
var use_group = true;


var paths = [];
getPathItemsInSelection(1, paths);
if( paths.length < 1 ){
alert("nothing to do with this script\r"
+ "because there's no path in the selection");
return;
}

var grp = use_group
? activeDocument.activeLayer.groupItems.add()
: undefined;

for (var i = 0; i < paths.length; i++){
if (paths[i].strokeDashes.length > 0){
breakDashes(paths[i], grp);
}
}
}

// --------------------------------------------
function breakDashes(line, grp){
var sd = line.strokeDashes;

if(sd.length == 1){
sd.push(sd[0]);
}

for (var i = 0; i < line.pathPoints.length; i++){
var next_i = parseIdx(line.pathPoints, i + 1);
if(next_i < 0) break;

// gets the anchor points on both ends
var a1 = line.pathPoints[i].anchor;
var a2 = line.pathPoints[next_i].anchor;

// if the line is curve, it needs another method
if(!arrEq(a1, line.pathPoints[i].rightDirection)
|| !arrEq(a2, line.pathPoints[next_i].leftDirection)){
breakDashesForCurve(line, i, next_i, sd, grp);
continue;
}

// gets the angle in radian
var t = getRad(a1, a2);

var line_length = dist(a1, a2);

var sd1 = adjustDashes(sd, line_length);

// draws a segment as a line with no dashes
// if the length of the segment is shorter
// than 1st dash.
if(sd1.length < 1){
var p = line.duplicate();
p.closed = false;
p.strokeDashes = [];
p.setEntirePath([a1, a2]);
if(grp) p.move(grp, ElementPlacement.PLACEATEND);
continue;
}

var offset = sd1[0] / 2;

var total_length = 0;
var is_gap = true;
var finish = false;

while(true){
for(var j = 0; j < sd1.length; j++){
var d = sd1[j];

if(offset > 0){
d -= offset;
offset = 0;
}

total_length += d;

if( total_length >= line_length ){
var a3 = a2;
finish = true;
} else {
var a3 = [ Math.cos(t) * d + a1[0],
Math.sin(t) * d + a1[1] ];
}

is_gap = (! is_gap);
if(! is_gap){
var p = line.duplicate();
p.closed = false;
p.strokeDashes = [];
p.setEntirePath([a1, a3]);
if(grp) p.move(grp, ElementPlacement.PLACEATEND);
}
a1 = a3;
if(finish) break;
}
if(finish) break;
}
}

line.remove();
}
// ----------------------------------------------
function adjustDashes(sd, line_length, grp){
var sd1;

var dashes_length = 0;
for (var i = 0; i < sd.length; i++){
dashes_length += sd[i];
}

if(dashes_length == 0){
sd1 = [];

} else if(sd[0] > 0 && line_length <= sd[0]){
sd1 = [];

} else {
var dashes_count = Math.floor(line_length / dashes_length + 0.6) || 1;

sd1 = sd.slice(0);

var ratio = line_length / (dashes_count * dashes_length);

for(var j = 0; j < sd1.length; j++){
sd1[j] *= ratio;
}
}

return sd1;
}
// ----------------------------------------------
// return distance between p1 [x,y], p2 [x,y]
function dist(p1, p2) {
return Math.sqrt( Math.pow(p1[0] - p2[0], 2)
+ Math.pow(p1[1] - p2[1], 2) );
}
// ----------------------------------------------
// return angle of the line drawn from "p1" [x,y] to "p2" [x,y]
function getRad(p1, p2) {
return Math.atan2(p2[1] - p1[1], p2[0] - p1[0]);
}
// --------------------------------------
// if the contents of both arrays are equal, return true (lengthes must be same)
function arrEq(arr1, arr2) {
for(var i = 0; i < arr1.length; i++){
if (arr1[i] != arr2[i]) return false;
}
return true;
}
// ----------------------------------------------
// return the index of pathpoint. when the argument is out of bounds,
// fixes it if the path is closed (ex. next of last index is 0),
// or return -1 if the path is not closed.
function parseIdx(p, n){ // PathPoints, number for index
var len = p.length;
if( p.parent.closed ){
return n >= 0 ? n % len : len - Math.abs(n % len);
} else {
return (n < 0 || n > len - 1) ? -1 : n;
}
}
// ------------------------------------------------
// extracts PathItems from the selection which length of PathPoints
// is greater than "n"
function getPathItemsInSelection(n, paths){
if(documents.length < 1) return;

var s = activeDocument.selection;

if (!(s instanceof Array) || s.length < 1) return;

extractPaths(s, n, paths);
}
// --------------------------------------
// extracts PathItems from "s" (Array of PageItems -- ex. selection),
// and put them into an Array "paths". If "pp_length_limit" is specified,
// this function extracts PathItems which PathPoints length is greater
// than this number.
function extractPaths(s, pp_length_limit, paths){
for(var i = 0; i < s.length; i++){
if(s[i].locked || s[i].hidden){
continue;
} else if(s[i].typename == "PathItem"){
if(pp_length_limit
&& s[i].pathPoints.length <= pp_length_limit){
continue;
}
paths.push(s[i]);

} else if(s[i].typename == "GroupItem"){
// search for PathItems in GroupItem, recursively
extractPaths(s[i].pageItems, pp_length_limit, paths);

} else if(s[i].typename == "CompoundPathItem"){
// searches for pathitems in CompoundPathItem, recursively
// ( ### Grouped PathItems in CompoundPathItem are ignored ### )
extractPaths(s[i].pathItems, pp_length_limit , paths);
}
}
}
// -----------------------------------------------
var Point = function(){
this.x = 0;
this.y = 0;
}
Point.prototype = {
set : function(x, y){
this.x = x;
this.y = y;
return this;
},
setr : function(xy){ // set with an array
this.x = xy[0];
this.y = xy[1];
return this;
},
setp : function(p){ // set with a Point
this.x = p.x;
this.y = p.y;
return this;
},
addp : function(p){
return new Point().set( this.x + p.x, this.y + p.y );
},
subp : function(p){
return new Point().set( this.x - p.x, this.y - p.y );
},
mul : function(m){
return new Point().set( this.x * m, this.y * m );
},
rotate : function(rad){
var s = Math.sin(rad);
var c = Math.cos(rad);
return new Point().set( this.x * c - this.y * s, this.x * s + this.y * c );
},
getAngle : function(){
return Math.atan2( this.y, this.x ); // radian
},
normalize : function(){
var d = Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
var p = new Point();
if( d == 0 ){
p.set(0,0);
} else {
p.set(this.x / d, this.y / d);
}
return p;
},
toArray : function(){
return [this.x, this.y];
}
}

// -----------------------------------------------
var Curve = function(path, idx1, idx2){
this.path = path;
this.idx1 = idx1;
this.idx2 = idx2;

var pts = path.pathPoints;

this.p1 = new Point().setr(pts[idx1].anchor);
this.rdir = new Point().setr(pts[idx1].rightDirection);
this.ldir = new Point().setr(pts[idx2].leftDirection);
this.p2 = new Point().setr(pts[idx2].anchor);

this.q = [this.p1, this.rdir, this.ldir, this.p2];
this.params = null;
this.length = null;
}
Curve.prototype = {
bezier : function(t){
var u = 1 - t;
return new Point().set(
u*u*u * this.p1.x + 3*u*t*(u* this.rdir.x + t* this.ldir.x) + t*t*t * this.p2.x,
u*u*u * this.p1.y + 3*u*t*(u* this.rdir.y + t* this.ldir.y) + t*t*t * this.p2.y);
},
setParams : function(){
var m = [this.p2.x - this.p1.x + 3 * (this.rdir.x - this.ldir.x),
this.p1.x - 2 * this.rdir.x + this.ldir.x,
this.rdir.x - this.p1.x];
var n = [this.p2.y - this.p1.y + 3 * (this.rdir.y - this.ldir.y),
this.p1.y - 2 * this.rdir.y + this.ldir.y,
this.rdir.y - this.p1.y];

this.params = [ m[0] * m[0] + n[0] * n[0],
4 * (m[0] * m[1] + n[0] * n[1]),
2 * ((m[0] * m[2] + n[0] * n[2]) + 2 * (m[1] * m[1] + n[1] * n[1])),
4 * (m[1] * m[2] + n[1] * n[2]),
m[2] * m[2] + n[2] * n[2]];
},
clone : function(){
var c = new Curve(this.path, this.idx1, this.idx2);
c.params = this.params;
c.length = this.length;
return c;
},
getLength : function(t){
//if( !this.params ) this.setParams();
var k = this.params;

var h = t / 128;
var hh = h * 2;

var fc = function(t, k){
return Math.sqrt(t * (t * (t * (t * k[0] + k[1]) + k[2]) + k[3]) + k[4]) || 0 };

var total = (fc(0, k) - fc(t, k)) / 2;

for(var i = h; i < t; i += hh){
total += 2 * fc(i, k) + fc(i + h, k);
}

return total * hh;
},
getLeftDirForT : function(t){
return new Point().set(
t * (t * (this.p1.x - 2 * this.rdir.x + this.ldir.x) + 2 * (this.rdir.x - this.p1.x)) + this.p1.x,
t * (t * (this.p1.y - 2 * this.rdir.y + this.ldir.y) + 2 * (this.rdir.y - this.p1.y)) + this.p1.y);
},
getRightDirForT : function(t){
return new Point().set(
t * (t * (this.rdir.x - 2 * this.ldir.x + this.p2.x) + 2 * (this.ldir.x - this.rdir.x)) + this.rdir.x,
t * (t * (this.rdir.y - 2 * this.ldir.y + this.p2.y) + 2 * (this.ldir.y - this.rdir.y)) + this.rdir.y);
},
resetPoints : function(p1, rdir, ldir, p2){
this.p1 = p1; this.rdir = rdir; this.ldir = ldir; this.p2 = p2;
this.q = [p1, rdir, ldir, p2];
},
getContractedRdir : function(m){
return this.p1.addp(this.rdir.subp(this.p1).mul(m));
},
getContractedLdir : function(m){
return this.p2.addp(this.ldir.subp(this.p2).mul(m));
},
getPartForTAndLength : function(t, len){
var c = this.clone();
c.resetPoints(this.bezier(t), this.getRightDirForT(t),
this.getContractedLdir(1 - t), this.p2);
c.setParams();
c.length = c.getLength(1);
var t1 = c.getTforLength(len);
c.resetPoints(c.p1, c.getContractedRdir(t1),
c.getLeftDirForT(t1), c.bezier(t1));
return c;
},
getTforLength : function(len){
//if( !this.params ) this.setParams();
var k = this.params;

//if( !this.length) this.length = this.getLength(1);
if(len <= 0){
return 0;
} else if(len > this.length){
return 1;
}

var t, d;
var t0 = 0;
var t1 = 1;
var torelance = 0.001;

for(var h = 1; h < 30; h++){
t = t0 + (t1 - t0) / 2;
d = len - this.getLength(t);

if(Math.abs(d) < torelance) break;
else if(d < 0) t1 = t;
else t0 = t;
}

return Math.min(1, t);
}
}

// --------------------------------------------
function breakDashesForCurve(line, i, next_i, sd, grp){
var cv = new Curve(line, i, next_i);

cv.setParams();
cv.length = cv.getLength(1);

var line_length = cv.length;

var sd1 = adjustDashes(sd, line_length);

// draws a segment as a line with no dashes
// if the length of the segment is shorter
// than 1st dash.
if(sd1.length < 1){
var p = line.duplicate();
p.closed = false;
p.strokeDashes = [];
var pp = p.pathPoints;
var rdir = pp[i].rightDirection;
var ldir = pp[next_i].leftDirection;
p.setEntirePath([pp[i].anchor, pp[next_i].anchor]);
pp = p.pathPoints;
pp[0].rightDirection = rdir;
pp[1].leftDirectin = ldir;
if(grp) p.move(grp, ElementPlacement.PLACEATEND);
return;
}

var offset = sd1[0] / 2;

var total_length = 0;
var is_gap = true;
var finish = false;

while(true){
for(var j = 0; j < sd1.length; j++){
var d = sd1[j];

if(offset > 0){
d -= offset;
offset = 0;
}

if( total_length + d >= line_length ){
finish = true;
}

is_gap = (! is_gap);
if(! is_gap){
var t = cv.getTforLength(total_length);
var cv1 = cv.getPartForTAndLength(t, d);

var p = line.duplicate();
p.closed = false;
p.strokeDashes = [];
p.setEntirePath([cv1.p1.toArray(), cv1.p2.toArray()]);
p.pathPoints[0].rightDirection = cv1.rdir.toArray();
p.pathPoints[1].leftDirection = cv1.ldir.toArray();
if(grp) p.move(grp, ElementPlacement.PLACEATEND);
}

if(finish) break;

total_length += d;
}
if(finish) break;
}
}
// ----------------------------------------------
main();

[61766658]

作者: tanshiyu

用这个脚本，用这个脚本，用这个脚本，用这个脚本，用这个脚本。

// breakDashes.jsx
// adobe Illustrator CSx script
// breaks each dashed path into a series of lines
//
// USAGE:
// Select paths and run this script.
//
// NOTE1: Illustrator's native dashes adjustment
// feature is ignored because it is totally
// out ...

论坛对上传文件的格式有要求，像是脚本一类的，你可以做成压缩包，然后上传，当然，上传代码也可以。

[slam001]

论坛上前二天不是有位大哥上传了脚本了吗，很方便，也可以定义成图案画笔来实现。

[aprking]

作者: 1515390048

如图，在Ai中怎样把虚线快速剪成一小段的。(目的是导出CAD后，齿刀变成一条线了)

直接拼合透明度，勾选将所有描边转换为轮廓(S)

还要搞那么复杂的脚本做甚？

[姜椒蒜]

作者: tanshiyu

用这个脚本，用这个脚本，用这个脚本，用这个脚本，用这个脚本。

// breakDashes.jsx
// adobe Illustrator CSx script
// breaks each dashed path into a series of lines
//
// USAGE:
// Select paths and run this script.
//
// NOTE1: Illustrator's native dashes adjustment
// feature is ignored because it is totally
// out ...

额，大佬们下次代码就打个包上传吧，手机划拉半天才到底…之前有个帖子，是定义画笔的方法，我觉得挺好的，试了下可以原汁原味